Diff [c71b2568066cb39013d366dd0195e430de881e0e:7c782aff4b836a71e18dd75c37d3b3e43582a5bc] for / – Cforall

doc/LaTeXmacros/common.tex

-              rc71b256
+              r7c782af
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Sun Feb  4 10:38:26 2018
 %% Update Count     : 365
+%% Last Modified On : Tue Feb 13 08:19:07 2018
+%% Update Count     : 367
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \makeatother
 \newenvironment{quote2}{%
         \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindent\rightmargin\leftmargin}%
+\newenvironment{cquote}{%
+        \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindentlnth\rightmargin\leftmargin}%
         \item\relax
 }{%
         \endlist
 }% quote2
+}% cquote
 \newenvironment{rationale}{%
   \begin{quote2}\noindent$\Box$\enspace
+  \begin{cquote}\noindent$\Box$\enspace
 }{%
   \hfill\enspace$\Box$\end{quote2}
+  \hfill\enspace$\Box$\end{cquote}
 }%
 …
 \newenvironment{syntax}{
 \paragraph{Syntax}
 \begin{quote2}
+\begin{cquote}
 \begin{description}[noitemsep,leftmargin=\parindentlnth]
 }{
 \end{description}
 \end{quote2}
+\end{cquote}
+}
 % \def\syntax{\paragraph{Syntax}\trivlist\parindent=.5in\item[\hskip.5in]}

doc/papers/general/Paper.tex

-              rc71b256
+              r7c782af
 \usepackage{epic,eepic}
 \usepackage{xspace,calc,comment}
+\usepackage{upquote}                                                                    % switch curled `'" to straight
+\usepackage{listings}                                                                   % format program code
+\usepackage{upquote}                                            % switch curled `'" to straight
+\usepackage{listings}                                           % format program code
+\usepackage{enumitem}
+\usepackage[flushmargin]{footmisc}                      % support label/reference in footnote
 \usepackage{rotating}
 \usepackage[usenames]{color}
 \usepackage{pslatex}                                    % reduce size of san serif font
+\usepackage{pslatex}                                            % reduce size of san serif font
 \usepackage[plainpages=false,pdfpagelabels,pdfpagemode=UseNone,pagebackref=true,breaklinks=true,colorlinks=true,linkcolor=blue,citecolor=blue,urlcolor=blue]{hyperref}
 \setlength{\textheight}{9in}
 %\oddsidemargin 0.0in
 \renewcommand{\topfraction}{0.8}                % float must be greater than X of the page before it is forced onto its own page
 \renewcommand{\bottomfraction}{0.8}             % float must be greater than X of the page before it is forced onto its own page
 \renewcommand{\floatpagefraction}{0.8}  % float must be greater than X of the page before it is forced onto its own page
 \renewcommand{\textfraction}{0.0}               % the entire page maybe devoted to floats with no text on the page at all
 \lefthyphenmin=4                                                % hyphen only after 4 characters
+\renewcommand{\topfraction}{0.8}                        % float must be greater than X of the page before it is forced onto its own page
+\renewcommand{\bottomfraction}{0.8}                     % float must be greater than X of the page before it is forced onto its own page
+\renewcommand{\floatpagefraction}{0.8}          % float must be greater than X of the page before it is forced onto its own page
+\renewcommand{\textfraction}{0.0}                       % the entire page maybe devoted to floats with no text on the page at all
+\lefthyphenmin=4                                                        % hyphen only after 4 characters
 \righthyphenmin=4
 …
 \newcommand{\CFAIcon}{\textsf{C}\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}\xspace} % Cforall symbolic name
 \newcommand{\CFA}{\protect\CFAIcon} % safe for section/caption
 \newcommand{\CFL}{\textrm{Cforall}\xspace} % Cforall symbolic name
 \newcommand{\Celeven}{\textrm{C11}\xspace} % C11 symbolic name
+\newcommand{\CFA}{\protect\CFAIcon}             % safe for section/caption
+\newcommand{\CFL}{\textrm{Cforall}\xspace}      % Cforall symbolic name
+\newcommand{\Celeven}{\textrm{C11}\xspace}      % C11 symbolic name
 \newcommand{\CC}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}\xspace} % C++ symbolic name
 \newcommand{\CCeleven}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}11\xspace} % C++11 symbolic name
 …
 \newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}}
 \newlength{\gcolumnposn}                                % temporary hack because lstlisting does not handle tabs correctly
+\newlength{\gcolumnposn}                                        % temporary hack because lstlisting does not handle tabs correctly
 \newlength{\columnposn}
 \setlength{\gcolumnposn}{2.75in}
 …
 % Latin abbreviation
 \newcommand{\abbrevFont}{\textit}       % set empty for no italics
+\newcommand{\abbrevFont}{\textit}                       % set empty for no italics
 \newcommand{\EG}{\abbrevFont{e}.\abbrevFont{g}.}
 \newcommand*{\eg}{%
 …
 \newenvironment{cquote}{%
         \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindent\rightmargin\leftmargin}%
+        \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindentlnth\rightmargin\leftmargin}%
         \item\relax
 }{%
 …
 \section{Introduction and Background}
+\section{Introduction}
 The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from commercial operating-systems to hobby projects.
 …
 The TIOBE~\cite{TIOBE} ranks the top 5 most popular programming languages as: Java 16\%, \Textbf{C 7\%}, \Textbf{\CC 5\%}, \Csharp 4\%, Python 4\% = 36\%, where the next 50 languages are less than 3\% each with a long tail.
 The top 3 rankings over the past 30 years are:
-\lstDeleteShortInline@%
 \begin{center}
 \setlength{\tabcolsep}{10pt}
+\lstDeleteShortInline@%
 \begin{tabular}{@{}rccccccc@{}}
                 & 2017  & 2012  & 2007  & 2002  & 1997  & 1992  & 1987          \\ \hline
 …
 \CC             & 3             & 3             & 3             & 3             & 2             & 2             & 4                     \\
 \end{tabular}
+\lstMakeShortInline@%
 \end{center}
-\lstMakeShortInline@%
 Love it or hate it, C is extremely popular, highly used, and one of the few systems languages.
 In many cases, \CC is often used solely as a better C.
 …
 The new constructs are empirically compared with both standard C and \CC; the results show the new design is comparable in performance.
+\subsection{Polymorphic Functions}
+\section{Polymorphic Functions}
+\CFA introduces both ad-hoc and parametric polymorphism to C, with a design originally formalized by Ditchfield~\cite{Ditchfield92}, and first implemented by Bilson~\cite{Bilson03}.
+\subsection{Name Overloading}
+C already has a limited form of ad-hoc polymorphism in the form of its basic arithmetic operators, which apply to a variety of different types using identical syntax.
+\CFA extends the built-in operator overloading by allowing users to define overloads for any function, not just operators, and even any variable; Section~\ref{sec:libraries} includes a number of examples of how this overloading simplifies \CFA programming relative to C.
+Code generation for these overloaded functions and variables is implemented by the usual approach of mangling the identifier names to include a representation of their type, while \CFA decides which overload to apply based on the same ``usual arithmetic conversions'' used in C to disambiguate operator overloads.
+As an example:
+\begin{cfa}
+int max(int a, int b) { return a < b ? b : a; }  // (1)
+double max(double a, double b) { return a < b ? b : a; }  // (2)
+int max = INT_MAX;     // (3)
+double max = DBL_MAX;  // (4)
+max(7, -max);   $\C{// uses (1) and (3), by matching int from constant 7}$
+max(max, 3.14); $\C{// uses (2) and (4), by matching double from constant 3.14}$
+//max(max, -max);  $\C{// ERROR: ambiguous}$
+int m = max(max, -max); $\C{// uses (1) once and (3) twice, by matching return type}$
+\end{cfa}
+\Celeven did add @_Generic@ expressions, which can be used in preprocessor macros to provide a form of ad-hoc polymorphism; however, this polymorphism is both functionally and ergonomically inferior to \CFA name overloading.
+The macro wrapping the generic expression imposes some limitations; as an example, it could not implement the example above, because the variables @max@ would collide with the functions @max@.
+Ergonomic limitations of @_Generic@ include the necessity to put a fixed list of supported types in a single place and manually dispatch to appropriate overloads, as well as possible namespace pollution from the functions dispatched to, which must all have distinct names.
+\subsection{\texorpdfstring{\LstKeywordStyle{forall} Functions}{forall Functions}}
 \label{sec:poly-fns}
-\CFA{}\hspace{1pt}'s polymorphism was originally formalized by Ditchfield~\cite{Ditchfield92}, and first implemented by Bilson~\cite{Bilson03}.
 The signature feature of \CFA is parametric-polymorphic functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a @forall@ clause (giving the language its name):
 \begin{lstlisting}
 …
 Crucial to the design of a new programming language are the libraries to access thousands of external software features.
 Like \CC, \CFA inherits a massive compatible library-base, where other programming languages must rewrite or provide fragile inter-language communication with C.
 A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted floating-point array:
+A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted float array:
 \begin{lstlisting}
 void * bsearch( const void * key, const void * base, size_t nmemb, size_t size,
 …
 int comp( const void * t1, const void * t2 ) { return *(double *)t1 < *(double *)t2 ? -1 :
                                 *(double *)t2 < *(double *)t1 ? 1 : 0; }
 double key = 5.0, vals[10] = { /* 10 sorted floating-point values */ };
+double key = 5.0, vals[10] = { /* 10 sorted float values */ };
 double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp );      $\C{// search sorted array}$
 \end{lstlisting}
 …
 Hence, programmers can easily form local environments, adding and modifying appropriate functions, to maximize reuse of other existing functions and types.
+Finally, \CFA allows variable overloading:
+\begin{lstlisting}
+short int MAX = ...;   int MAX = ...;  double MAX = ...;
+short int s = MAX;    int i = MAX;    double d = MAX;   $\C{// select correct MAX}$
+\end{lstlisting}
+Here, the single name @MAX@ replaces all the C type-specific names: @SHRT_MAX@, @INT_MAX@, @DBL_MAX@.
+%% Redundant with Section~\ref{sec:libraries} %%
+% Finally, \CFA allows variable overloading:
+% \begin{lstlisting}
+% short int MAX = ...;   int MAX = ...;  double MAX = ...;
+% short int s = MAX;    int i = MAX;    double d = MAX;   $\C{// select correct MAX}$
+% \end{lstlisting}
+% Here, the single name @MAX@ replaces all the C type-specific names: @SHRT_MAX@, @INT_MAX@, @DBL_MAX@.
 \subsection{Traits}
 …
 In many languages, functions can return at most one value;
 however, many operations have multiple outcomes, some exceptional.
 Consider C's @div@ and @remquo@ functions, which return the quotient and remainder for a division of integer and floating-point values, respectively.
+Consider C's @div@ and @remquo@ functions, which return the quotient and remainder for a division of integer and float values, respectively.
 \begin{lstlisting}
 typedef struct { int quo, rem; } div_t;         $\C{// from include stdlib.h}$
 …
 \section{Control Structures}
+\CFA identifies missing and problematic control structures in C, and extends and modifies these control structures to increase functionality and safety.
 …
 The implicit targets of the current @continue@ and @break@, \ie the closest enclosing loop or @switch@, change as certain constructs are added or removed.
 \subsection{\texorpdfstring{Enhanced \LstKeywordStyle{switch} Statement}{Enhanced switch Statement}}
+\CFA also fixes a number of ergonomic defecits in the @switch@ statements of standard C.
+C can specify a number of equivalent cases by using the default ``fall-through'' semantics of @case@ clauses, \eg @case 1: case 2: case 3:@ -- this syntax is cluttered, however, so \CFA includes a more concise list syntax, @case 1, 2, 3:@.
+For contiguous ranges, \CFA provides an even more concise range syntax as well, @case 1~3:@; lists of ranges are also allowed in case selectors.
+There are a number of deficiencies with the C @switch@ statements: enumerating @case@ lists, placement of @case@ clauses, scope of the switch body, and fall through between case clauses.
+C has no shorthand for specifying a list of case values, whether the list is non-contiguous or contiguous\footnote{C provides this mechanism via fall through.}.
+\CFA provides a shorthand for a non-contiguous list:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+case 2, 10, 34, 42:
+\end{cfa}
+&
+\begin{cfa}
+case 2: case 10: case 34: case 42:
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+for a contiguous list:\footnote{gcc provides the same mechanism with awkward syntax, \lstinline@2 ... 42@, where spaces are required around the ellipse.}
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+case 2~42:
+\end{cfa}
+&
+\begin{cfa}
+case 2: case 3: ... case 41: case 42:
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+and a combination:
+\begin{cfa}
+case -12~-4, -1~5, 14~21, 34~42:
+\end{cfa}
+C allows placement of @case@ clauses \emph{within} statements nested in the @switch@ body (see Duff's device~\cite{Duff83});
+\begin{cfa}
+switch ( i ) {
+  case 0:
+        for ( int i = 0; i < 10; i += 1 ) {
+                ...
+  `case 1:`             // no initialization of loop index
+                ...
+        }
+}
+\end{cfa}
+\CFA precludes this form of transfer into a control structure because it causes undefined behaviour, especially with respect to missed initialization, and provides very limited functionality.
+C allows placement of declaration within the @switch@ body and unreachable code at the start, resulting in undefined behaviour:
+\begin{cfa}
+switch ( x ) {
+        `int y = 1;`                            $\C{// unreachable initialization}$
+        `x = 7;`                                        $\C{// unreachable code without label/branch}$
+  case 0:
+        ...
+        `int z = 0;`                            $\C{// unreachable initialization, cannot appear after case}$
+        z = 2;
+  case 1:
+        `x = z;`                                        $\C{// without fall through, z is undefined}$
+}
+\end{cfa}
+\CFA allows the declaration of local variables, \eg @y@, at the start of the @switch@ with scope across the entire @switch@ body, \ie all @case@ clauses, but no statements.
+\CFA disallows the declaration of local variable, \eg @z@, directly within the @switch@ body, because a declaration cannot occur immediately after a @case@ since a label can only be attached to a statement, and the use of @z@ is undefined in @case 1@ as neither storage allocation nor initialization may have occurred.
+C @switch@ provides multiple entry points into the statement body, but once an entry point is selected, control continues across \emph{all} @case@ clauses until the end of the @switch@ body, called \newterm{fall through};
+@case@ clauses are made disjoint by the @break@ statement.
+While the ability to fall through \emph{is} a useful form of control flow, it does not match well with programmer intuition, resulting in many errors from missing @break@ statements.
+\CFA provides a new control structure, @choose@, which mimics @switch@, but reverses the meaning of fall through:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+`choose` ( day ) {
+  case Mon~Thu:
+        // program
+  case Fri:
+        // program
+        wallet += pay;
+        `fallthrough;`
+  case Sat:
+        // party
+        wallet -= party;
+  case Sun:
+        // rest
+  default:
+        // error
+}
+\end{cfa}
+&
+\begin{cfa}
+switch ( day ) {
+  case Mon: case Tue: case Wed: case Thu:
+        // program
+        `break;`
+  case Fri:
+        // program
+        wallet += pay;
+  case Sat:
+        // party
+        wallet -= party;
+        `break;`
+  case Sun:
+        // rest
+        `break;`
+  default:
+        // error
+}
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+Collectively, these enhancements reduce programmer burden and increase readability and safety.
+\begin{comment}
 Forgotten @break@ statements at the end of @switch@ cases are a persistent sort of programmer error in C, and the @break@ statements themselves introduce visual clutter and an un-C-like keyword-based block delimiter.
 \CFA addresses this error by introducing a @choose@ statement, which works identically to a @switch@ except that its default end-of-case behaviour is to break rather than to fall through for all non-empty cases.
 …
+}
 \end{cfa}
+\end{comment}
 \subsection{\texorpdfstring{\LstKeywordStyle{with} Clause / Statement}{with Clause / Statement}}
 …
 \end{cfa}
+\subsection{Exception Handling ???}
+% \subsection{Exception Handling ???}
 \section{Declarations}
 …
 \lstDeleteShortInline@%
 \lstset{moredelim=**[is][\color{blue}]{+}{+}}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 +[5] *+ `int` x1;
 +* [5]+ `int` x2;
 +[* [5] int]+ f`( int p )`;
+`[* [5] int]` f+( int p )+;
 \end{cfa}
+&
 …
 `int` +*+ x1 +[5]+;
 `int` +(*+x2+)[5]+;
 +int (*+f`( int p )`+)[5]+;
+`int (*`f+( int p )+`)[5]`;
 \end{cfa}
 \end{tabular}
 …
 \begin{cquote}
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 `*` int x, y;
 …
 \begin{cquote}
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 `*` int x;
 …
 \begin{cquote}
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{C}}      \\
 \begin{cfa}
 [ 5 ] int z;
 …
 \begin{cquote}
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}}
 \multicolumn{1}{c@{\hspace{1em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}} \\
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{C}}      \\
 \begin{cfa}
 const * const int x;
 …
 \begin{cquote}
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{C}}      \\
 \begin{cfa}
 extern [ 5 ] int x;
 …
 \begin{cquote}
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 y = (* int)x;
 …
 Therefore, a programmer has the option of either continuing to use traditional C declarations or take advantage of the new style.
 Clearly, both styles need to be supported for some time due to existing C-style header-files, particularly for UNIX-like systems.
+The syntax of the new routine prototype declaration follows directly from the new routine definition syntax;
+as well, parameter names are optional, \eg:
+\begin{cfa}
+[ int x ] f ();                                                 $\C{// returning int with no parameters}$
+[ * int ] g (int y);                                    $\C{// returning pointer to int with int parameter}$
+[ ] h ( int, char );                                    $\C{// returning no result with int and char parameters}$
+[ * int, int ] j ( int );                               $\C{// returning pointer to int and int, with int parameter}$
+\end{cfa}
+This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa).
+Like C, it is possible to declare multiple routine-prototypes in a single declaration, where the return type is distributed across \emph{all} routine names in the declaration list, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+[double] foo(), foo( int ), foo( double ) {...}
+\end{cfa}
+&
+\begin{cfa}
+double foo1(), foo2( int ), foo3( double );
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+\CFA allows the last routine in the list to define its body.
+Declaration qualifiers can only appear at the start of a \CFA routine declaration,\footref{StorageClassSpecifier} \eg:
+\begin{cfa}
+extern [ int ] f ( int );
+static [ int ] g ( int );
+\end{cfa}
+The syntax for pointers to \CFA routines specifies the pointer name on the right, \eg:
+\begin{cfa}
+* [ int x ] () fp;                                              $\C{// pointer to routine returning int with no parameters}$
+* [ * int ] (int y) gp;                                 $\C{// pointer to routine returning pointer to int with int parameter}$
+* [ ] (int,char) hp;                                    $\C{// pointer to routine returning no result with int and char parameters}$
+* [ * int,int ] ( int ) jp;                             $\C{// pointer to routine returning pointer to int and int, with int parameter}$
+\end{cfa}
+While parameter names are optional, \emph{a routine name cannot be specified};
+for example, the following is incorrect:
+\begin{cfa}
+* [ int x ] f () fp;                                    $\C{// routine name "f" is not allowed}$
+\end{cfa}
 …
 In addition to the expressive power, \lstinline|@=| provides a simple path for migrating legacy C code to \CFA, by providing a mechanism to incrementally convert initializers; the \CFA design team decided to introduce a new syntax for this escape hatch because we believe that our RAII implementation will handle the vast majority of code in a desirable way, and we wished to maintain familiar syntax for this common case.
+\subsection{Type Nesting}
+\CFA allows \newterm{type nesting}, and type qualification of the nested types (see Figure~\ref{f:TypeNestingQualification}), where as C hoists (refactors) nested types into the enclosing scope and has no type qualification.
+\begin{figure}
+\centering
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{3em}}l|l@{}}
+\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C Type Nesting}}      & \multicolumn{1}{c}{\textbf{C Implicit Hoisting}}      & \multicolumn{1}{|c}{\textbf{\CFA}}    \\
+\hline
+\begin{cfa}
+struct S {
+        enum C { R, G, B };
+        struct T {
+                union U { int i, j; };
+                enum C c;
+                short int i, j;
+        };
+        struct T t;
+} s;
+int rtn() {
+        s.t.c = R;
+        struct T t = { R, 1, 2 };
+        enum C c;
+        union U u;
+}
+\end{cfa}
+&
+\begin{cfa}
+enum C { R, G, B };
+union U { int i, j; };
+struct T {
+        enum C c;
+        short int i, j;
+};
+struct S {
+        struct T t;
+} s;
+\end{cfa}
+&
+\begin{cfa}
+struct S {
+        enum C { R, G, B };
+        struct T {
+                union U { int i, j; };
+                enum C c;
+                short int i, j;
+        };
+        struct T t;
+} s;
+int rtn() {
+        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{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\caption{Type Nesting / Qualification}
+\label{f:TypeNestingQualification}
+\end{figure}
+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 ``@::@''.
 \subsection{Default Parameters}
 …
 \section{Literals}
 C already includes limited polymorphism for literals -- @0@ can be either an integer or a pointer literal, depending on context, while the syntactic forms of literals of the various integer and floating-point types are very similar, differing from each other only in suffix.
+C already includes limited polymorphism for literals -- @0@ can be either an integer or a pointer literal, depending on context, while the syntactic forms of literals of the various integer and float types are very similar, differing from each other only in suffix.
 In keeping with the general \CFA approach of adding features while respecting ``the C way'' of doing things, we have extended both C's polymorphic zero and typed literal syntax to interoperate with user-defined types, while maintaining a backwards-compatible semantics.
 …
 struct Weight { double stones; };
 void ?{}( Weight & w ) { w.stones = 0; } $\C{// operations}$
+void ?{}( Weight & w ) { w.stones = 0; }        $\C{// operations}$
 void ?{}( Weight & w, double w ) { w.stones = w; }
 Weight ?+?( Weight l, Weight r ) { return (Weight){ l.stones + r.stones }; }
 …
 int main() {
         Weight w, hw = { 14 };                  $\C{// 14 stone}$
+        Weight w, hw = { 14 };                                  $\C{// 14 stone}$
         w = 11@`st@ + 1@`lb@;
         w = 70.3@`kg@;
         w = 155@`lb@;
         w = 0x_9b_u@`lb@;                               $\C{// hexadecimal unsigned weight (155)}$
         w = 0_233@`lb@;                                 $\C{// octal weight (155)}$
+        w = 0x_9b_u@`lb@;                                               $\C{// hexadecimal unsigned weight (155)}$
+        w = 0_233@`lb@;                                                 $\C{// octal weight (155)}$
         w = 5@`st@ + 8@`kg@ + 25@`lb@ + hw;
+}
 \end{cfa}
 }%
+\section{Libraries}
+\label{sec:libraries}
+As stated in Section~\ref{sec:poly-fns}, \CFA inherits a large corpus of library code, where other programming languages must rewrite or provide fragile inter-language communication with C.
+\CFA has replacement libraries condensing hundreds of existing C names into tens of \CFA overloaded names, all without rewriting the actual computations.
+In many cases, the interface is an inline wrapper providing overloading during compilation but zero cost at runtime.
+The following sections give a glimpse of the interface reduction to many C libraries.
+In many cases, @signed@/@unsigned@ @char@ and @short@ routines are available (but not shown) to ensure expression computations remain in a single type, as conversions can distort results.
+\subsection{Limits}
+C library @limits.h@ provides lower and upper bound constants for the basic types.
+\CFA name overloading is used to condense these typed constants, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Definition}}       & \multicolumn{1}{c}{\textbf{Usage}}    \\
+\begin{cfa}
+const short int `MIN` = -32768;
+const int `MIN` = -2147483648;
+const long int `MIN` = -9223372036854775808L;
+\end{cfa}
+&
+\begin{cfa}
+short int si = `MIN`;
+int i = `MIN`;
+long int li = `MIN`;
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+The result is a significant reduction in names to access typed constants, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+MIN
+MAX
+M_PI
+M_E
+\end{cfa}
+&
+\begin{cfa}
+SCHAR_MIN, CHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN,
+SCHAR_MAX, UCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX,
+M_PI, M_PIl, M_CPI, M_CPIl,
+M_E, M_El, M_CE, M_CEl
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+\subsection{Math}
+C library @math.h@ provides many mathematical routines.
+\CFA routine overloading is used to condense these mathematical routines, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Definition}}       & \multicolumn{1}{c}{\textbf{Usage}}    \\
+\begin{cfa}
+float `log`( float x );
+double `log`( double );
+double _Complex `log`( double _Complex x );
+\end{cfa}
+&
+\begin{cfa}
+float f = `log`( 3.5 );
+double d = `log`( 3.5 );
+double _Complex dc = `log`( 3.5+0.5I );
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+The result is a significant reduction in names to access math routines, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+log
+sqrt
+sin
+\end{cfa}
+&
+\begin{cfa}
+logf, log, logl, clogf, clog, clogl
+sqrtf, sqrt, sqrtl, csqrtf, csqrt, csqrtl
+sinf, sin, sinl, csinf, csin, csinl
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+While \Celeven has type-generic math~\cite[\S~7.25]{C11} in @tgmath.h@ to provide a similar mechanism, these macros are limited, matching a routine name with a single set of floating type(s).
+For example, it is not possible to overload @atan@ for both one and two arguments;
+instead the names @atan@ and @atan2@ are required.
+The key observation is that only a restricted set of type-generic macros are provided for a limited set of routine names, which do not generalize across the type system, as in \CFA.
+\subsection{Standard}
+C library @stdlib.h@ provides many general routines.
+\CFA routine overloading is used to condense these utility routines, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Definition}}       & \multicolumn{1}{c}{\textbf{Usage}}    \\
+\begin{cfa}
+unsigned int `abs`( int );
+double `abs`( double );
+double abs( double _Complex );
+\end{cfa}
+&
+\begin{cfa}
+unsigned int i = `abs`( -1 );
+double d = `abs`( -1.5 );
+double d = `abs`( -1.5+0.5I );
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+The result is a significant reduction in names to access utility routines, \eg:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+abs
+strto
+random
+\end{cfa}
+&
+\begin{cfa}
+abs, labs, llabs, fabsf, fabs, fabsl, cabsf, cabs, cabsl
+strtol, strtoul, strtoll, strtoull, strtof, strtod, strtold
+srand48, mrand48, lrand48, drand48
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+In additon, there are polymorphic routines, like @min@ and @max@, which work on any type with operators @?<?@ or @?>?@.
+The following shows one example where \CFA \emph{extends} an existing standard C interface to reduce complexity and provide safety.
+C/\Celeven provide a number of complex and overlapping storage-management operation to support the following capabilities:
+\begin{description}[itemsep=2pt,parsep=0pt]
+\item[fill]
+after allocation the storage is filled with a specified character.
+\item[resize]
+an existing allocation is decreased or increased in size.
+In either case, new storage may or may not be allocated and, if there is a new allocation, as much data from the existing allocation is copied.
+For an increase in storage size, new storage after the copied data may be filled.
+\item[alignment]
+an allocation starts on a specified memory boundary, \eg, an address multiple of 64 or 128 for cache-line purposes.
+\item[array]
+the allocation size is scaled to the specified number of array elements.
+An array may be filled, resized, or aligned.
+\end{description}
+Table~\ref{t:StorageManagementOperations} shows the capabilities provided by C/\Celeven allocation-routines and how all the capabilities can be combined into two \CFA routines.
+\CFA storage-management routines extend the C equivalents by overloading, providing shallow type-safety, and removing the need to specify the base allocation-size.
+The following example contrasts \CFA and C storage-allocation operation performing the same operations with the same type safety:
+\begin{cquote}
+\begin{cfa}[aboveskip=0pt]
+size_t  dim = 10;                                                       $\C{// array dimension}$
+char fill = '\xff';                                                     $\C{// initialization fill value}$
+int * ip;
+\end{cfa}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+ip = alloc();
+ip = alloc( fill );
+ip = alloc( dim );
+ip = alloc( dim, fill );
+ip = alloc( ip, 2 * dim );
+ip = alloc( ip, 4 * dim, fill );
+ip = align_alloc( 16 );
+ip = align_alloc( 16, fill );
+ip = align_alloc( 16, dim );
+ip = align_alloc( 16, dim, fill );
+\end{cfa}
+&
+\begin{cfa}
+ip = (int *)malloc( sizeof( int ) );
+ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, sizeof( int ) );
+ip = (int *)malloc( dim * sizeof( int ) );
+ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) );
+ip = (int *)realloc( ip, 2 * dim * sizeof( int ) );
+ip = (int *)realloc( ip, 4 * dim * sizeof( int ) ); memset( ip, fill, 4 * dim * sizeof( int ) );
+ip = memalign( 16, sizeof( int ) );
+ip = memalign( 16, sizeof( int ) ); memset( ip, fill, sizeof( int ) );
+ip = memalign( 16, dim * sizeof( int ) );
+ip = memalign( 16, dim * sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) );
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+Variadic @new@ (see Section~\ref{sec:variadic-tuples}) cannot support the same overloading because extra parameters are for initialization.
+Hence, there are @new@ and @anew@ routines for single and array variables, and the fill value is the arguments to the constructor, \eg:
+\begin{cfa}
+struct S { int i, j; };
+void ?{}( S & s, int i, int j ) { s.i = i; s.j = j; }
+S * s = new( 2, 3 );                                            $\C{// allocate storage and run constructor}$
+S * as = anew( dim, 2, 3 );                                     $\C{// each array element initialized to 2, 3}$
+\end{cfa}
+Note, \CC can only initialization array elements via the default constructor.
+Finally, the \CFA memory-allocator has \newterm{sticky properties} for dynamic storage: fill and alignment are remembered with an object's storage in the heap.
+When a @realloc@ is performed, the sticky properties are respected, so that new storage is correctly aligned and initialized with the fill character.
+\begin{table}
+\centering
+\lstDeleteShortInline@%
+\lstMakeShortInline~%
+\begin{tabular}{@{}r|r|l|l|l|l@{}}
+\multicolumn{1}{c}{}&           & \multicolumn{1}{c|}{fill}     & resize        & alignment     & array \\
+\hline
+C               & ~malloc~                      & no                    & no            & no            & no    \\
+                & ~calloc~                      & yes (0 only)  & no            & no            & yes   \\
+                & ~realloc~                     & no/copy               & yes           & no            & no    \\
+                & ~memalign~            & no                    & no            & yes           & no    \\
+                & ~posix_memalign~      & no                    & no            & yes           & no    \\
+\hline
+C11             & ~aligned_alloc~       & no                    & no            & yes           & no    \\
+\hline
+\CFA    & ~alloc~                       & yes/copy              & no/yes        & no            & yes   \\
+                & ~align_alloc~         & yes                   & no            & yes           & yes   \\
+\end{tabular}
+\lstDeleteShortInline~%
+\lstMakeShortInline@%
+\caption{Storage-Management Operations}
+\label{t:StorageManagementOperations}
+\end{table}
+\subsection{I/O}
+\label{s:IOLibrary}
+The goal of \CFA I/O is to simplify the common cases, while fully supporting polymorphism and user defined types in a consistent way.
+The approach combines ideas from \CC and Python.
+The \CFA header file for the I/O library is @fstream@.
+The common case is printing out a sequence of variables separated by whitespace.
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{\CC}}      \\
+\begin{cfa}
+int x = 1, y = 2, z = 3;
+sout | x `|` y `|` z | endl;
+\end{cfa}
+&
+\begin{cfa}
+cout << x `<< " "` << y `<< " "` << z << endl;
+\end{cfa}
+\\
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+` `2` `3
+\end{cfa}
+&
+\begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+2 3
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+The \CFA form has half the characters of the \CC form, and is similar to Python I/O with respect to implicit separators.
+Similar simplification occurs for tuple I/O, which prints all tuple values separated by ``\lstinline[showspaces=true]@, @''.
+\begin{cfa}
+[int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ];
+sout | t1 | t2 | endl;                                  $\C{// print tuples}$
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt]
+`, `2`, `3 4`, `5`, `6
+\end{cfa}
+Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority overloadable operator, other than assignment.
+Therefore, fewer output expressions require parenthesis.
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}ll@{}}
+\textbf{\CFA:}
+&
+\begin{cfa}
+sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
+\end{cfa}
+\\
+\textbf{\CC:}
+&
+\begin{cfa}
+cout << x * 3 << y + 1 << `(`z << 2`)` << `(`x == y`)` << (x | y) << (x || y) << (x > z ? 1 : 2) << endl;
+\end{cfa}
+\\
+\textbf{output:}
+&
+\begin{cfa}[showspaces=true,aboveskip=0pt]
+3 12 0 3 1 2
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+There is a weak similarity between the \CFA logical-or operator and the Shell pipe-operator for moving data, where data flows in the correct direction for input but the opposite direction for output.
+The implicit separator character (space/blank) is a separator not a terminator.
+The rules for implicitly adding the separator are:
+\begin{itemize}[itemsep=2pt,parsep=0pt]
+\item
+A separator does not appear at the start or end of a line.
+\item
+A separator does not appear before or after a character literal or variable.
+\item
+A separator does not appear before or after a null (empty) C string, which is a local mechanism to disable insertion of the separator character.
+\item
+A separator does not appear before a C string starting with the characters: \lstinline[mathescape=off,basicstyle=\tt]@([{=$@
+\item
+A seperator does not appear after a C string ending with the characters: \lstinline[basicstyle=\tt]@,.;!?)]}%@
+\item
+{\lstset{language=CFA,deletedelim=**[is][]{`}{`}}
+A seperator does not appear before or after a C string begining/ending with the quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]@`'": \t\v\f\r\n@
+}%
+\item
+There are routines to set and get the separator string, and manipulators to toggle separation on and off in the middle of output.
+\end{itemize}
+\subsection{Multi-precision Integers}
+\label{s:MultiPrecisionIntegers}
+\CFA has an interface to the GMP multi-precision signed-integers~\cite{GMP}, similar to the \CC interface provided by GMP.
+The \CFA interface wraps GMP routines into operator routines to make programming with multi-precision integers identical to using fixed-sized integers.
+The \CFA type name for multi-precision signed-integers is @Int@ and the header file is @gmp@.
+The following multi-precision factorial programs contrast using GMP with the \CFA and C interfaces.
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}      \\
+\begin{cfa}
+#include <gmp>
+int main( void ) {
+        sout | "Factorial Numbers" | endl;
+        Int fact = 1;
+        sout | 0 | fact | endl;
+        for ( unsigned int i = 1; i <= 40; i += 1 ) {
+                fact *= i;
+                sout | i | fact | endl;
+        }
+}
+\end{cfa}
+&
+\begin{cfa}
+#include <gmp.h>
+int main( void ) {
+        `gmp_printf`( "Factorial Numbers\n" );
+        `mpz_t` fact;
+        `mpz_init_set_ui`( fact, 1 );
+        `gmp_printf`( "%d %Zd\n", 0, fact );
+        for ( unsigned int i = 1; i <= 40; i += 1 ) {
+                `mpz_mul_ui`( fact, fact, i );
+                `gmp_printf`( "%d %Zd\n", i, fact );
+        }
+}
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
 \section{Evaluation}
 …
 \begin{table}
+\centering
 \caption{Properties of benchmark code}
 \label{tab:eval}

doc/user/user.tex

-              rc71b256
+              r7c782af
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Wed Jan 31 22:29:25 2018
 %% Update Count     : 3147
+%% Last Modified On : Tue Feb 13 08:31:21 2018
+%% Update Count     : 3161
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 Like \Index*[C++]{\CC{}}, there may be both an old and new ways to achieve the same effect.
 For example, the following programs compare the \CFA, C, and \CC I/O mechanisms, where the programs output the same result.
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{1.5em}}l@{\hspace{1.5em}}l@{}}
 \multicolumn{1}{c@{\hspace{1.5em}}}{\textbf{C}} & \multicolumn{1}{c}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{\CC}}      \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 While the \CFA I/O looks similar to the \Index*[C++]{\CC{}} output style, there are important differences, such as automatic spacing between variables as in \Index*{Python} (see~\VRef{s:IOLibrary}).
 …
 \begin{comment}
 A simple example is leveraging the existing type-unsafe (©void *©) C ©bsearch© to binary search a sorted floating-point array:
+A simple example is leveraging the existing type-unsafe (©void *©) C ©bsearch© to binary search a sorted floating array:
 \begin{lstlisting}
 void * bsearch( const void * key, const void * base, size_t dim, size_t size,
 …
                                 *(double *)t2 < *(double *)t1 ? 1 : 0; }
 double key = 5.0, vals[10] = { /* 10 sorted floating-point values */ };
+double key = 5.0, vals[10] = { /* 10 sorted floating values */ };
 double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp );      $\C{// search sorted array}$
 \end{lstlisting}
 …
 x®_®ff®_®ff;                                                   §\C{// hexadecimal constant}§
 x®_®ef3d®_®aa5c;                                               §\C{// hexadecimal constant}§
 .141®_®592®_®654;                                              §\C{// floating point constant}§
 ®_®e®_®+1®_®00;                                               §\C{// floating point constant}§
 x®_®ff®_®ff®_®p®_®3;                                   §\C{// hexadecimal floating point}§
 x®_®1.ffff®_®ffff®_®p®_®128®_®l;               §\C{// hexadecimal floating point long constant}§
+.141®_®592®_®654;                                              §\C{// floating constant}§
+®_®e®_®+1®_®00;                                               §\C{// floating constant}§
+x®_®ff®_®ff®_®p®_®3;                                   §\C{// hexadecimal floating}§
+x®_®1.ffff®_®ffff®_®p®_®128®_®l;               §\C{// hexadecimal floating long constant}§
 L®_®§"\texttt{\textbackslash{x}}§®_®§\texttt{ff}§®_®§\texttt{ee}"§;     §\C{// wide character constant}§
 \end{cfa}
 …
 \label{f:HeaderFileInterposition}
 \end{figure}
+\section{Exponentiation Operator}
+C, \CC, and Java (and many other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow}, to perform the exponentiation operation.
+\CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@\lstinline$?\?$} and ©?\=?©\index{?\\=?@\lstinline$?\=?$}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
+The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©((w * (((int)x) \ ((int)y))) * z)©.
+As for \Index{division}, there are exponentiation operators for integral and floating types, including the builtin \Index{complex} types.
+Unsigned integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is $O(\log y)$.} (or shifting if the base is 2).
+Signed integral exponentiation\index{exponentiation!signed integral} is performed with repeated multiplication (or shifting if the base is 2), but yields a floating result because $x^{-y}=1/x^y$.
+Hence, it is important to designate exponent integral-constants as unsigned or signed: ©3 \ 3u© return an integral result, while ©3 \ 3© returns a floating result.
+Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the base cannot be negative.
+\begin{cfa}
+sout | 2 ®\® 8u | 4 ®\® 3u | -4 ®\® 3u | 4 ®\® -3 | -4 ®\® -3 | 4.0 ®\® 2.1 | (1.0f+2.0fi) ®\® (3.0f+2.0fi) | endl;
+64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
+\end{cfa}
+Parenthesis are necessary for the complex constants or the expresion is parsed as ©1.0f+(2.0fi \ 3.0f)+2.0fi©.
+The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation versions are available.
+For returning an integral value, the user type ©T© must define multiplication, ©*©, and one, ©1©;
+for returning a floating value, an additional divide of type ©T© into a ©double© returning a ©double© (©double ?/?( double, T )©) is necessary for negative exponents.
 …
 \end{cfa}
 The ability to fall-through to the next clause \emph{is} a useful form of control flow, specifically when a sequence of case actions compound:
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \begin{cfa}
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 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 ©switch© statement without fall-through as code must be duplicated or placed in a separate routine.
 …
         ®int y = 1;®                            §\C{// unreachable initialization}§
         ®x = 7;®                                        §\C{// unreachable code without label/branch}§
   case 3: ...
+  case 0: ...
         ...
         ®int z = 0;®                            §\C{// unreachable initialization, cannot appear after case}§
         z = 2;
   case 3:
+  case 1:
         ®x = z;®                                        §\C{// without fall through, z is uninitialized}§
+}
 …
 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{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 In addition, two forms of subranges are allowed to specify case values: a new \CFA form and an existing GNU C form.\footnote{
 The GNU C form \emph{requires} spaces around the ellipse.}
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{GNU C}}     \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 Lists of subranges are also allowed.
 \begin{cfa}
 …
+}
 \end{C++}
 Since CFA is non-object-oriented, the equivalent object-oriented program looks like:
+Since \CFA is non-object-oriented, the equivalent object-oriented program looks like:
 \begin{cfa}
 struct S { int i, j; };
 int mem( S &®this® ) {                  §\C{// explicit "this" parameter}§
+int mem( S & ®this® ) {                 §\C{// explicit "this" parameter}§
         ®this.®i = 1;                           §\C{// "this" is not elided}§
         ®this.®j = 2;
+}
 \end{cfa}
 but it is cumbersome having to write "©this.©" many times in a member.
+but it is cumbersome having to write ``©this.©'' many times in a member.
 \CFA provides a ©with© clause/statement (see Pascal~\cite[\S~4.F]{Pascal}) to elided the "©this.©" by opening a scope containing field identifiers, changing the qualified fields into variables and giving an opportunity for optimizing qualified references.
 \begin{cfa}
 int mem( S &this ) ®with this® { §\C{// with clause}§
         i = 1;                                          §\C{\color{red}// this->i}§
         j = 2;                                          §\C{\color{red}// this->j}§
+int mem( S & this ) ®with this® { §\C{// with clause}§
+        i = 1;                                          §\C{\color{red}// this.i}§
+        j = 2;                                          §\C{\color{red}// this.j}§
+}
 \end{cfa}
 …
 \begin{cfa}
 struct T { double m, n; };
 int mem2( S &this1, T &this2 ) ®with this1, this2® {
+int mem2( S & this1, T & this2 ) ®with this1, this2® {
         i = 1; j = 2;
         m = 1.0; n = 2.0;
 …
         struct S1 { ... } s1;
         struct S2 { ... } s2;
         ®with s1® {                     // with statement
+        ®with s1® {                                     §\C{// with statement}§
                 // access fields of s1 without qualification
                 ®with s2® {  // nesting
+                ®with s2® {                             §\C{// nesting}§
                         // access fields of s1 and s2 without qualification
+                }
 …
 \section{Declarations}
 \label{s:Declarations}
+\section{Alternative Declarations}
+\label{s:AlternativeDeclarations}
 C declaration syntax is notoriously confusing and error prone.
 For example, many C programmers are confused by a declaration as simple as:
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}ll@{}}
 \begin{cfa}
 …
 \raisebox{-0.75\totalheight}{\input{Cdecl}}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 Is this an array of 5 pointers to integers or a \Index{pointer} to an array of 5 integers?
 The fact this declaration is unclear to many C programmers means there are \Index{productivity} and \Index{safety} issues even for basic programs.
+If there is any doubt, it implies \Index{productivity} and \Index{safety} issues even for basic programs.
 Another example of confusion results from the fact that a routine name and its parameters are embedded within the return type, mimicking the way the return value is used at the routine's call site.
 For example, a routine returning a \Index{pointer} to an array of integers is defined and used in the following way:
 \begin{cfa}
 int ®(*®f®())[®5®]® {...};                              §\C{definition}§
  ... ®(*®f®())[®3®]® += 1;                              §\C{usage}§
+int ®(*®f®())[®5®]® {...};                              §\C{// definition}§
+ ... ®(*®f®())[®3®]® += 1;                              §\C{// usage}§
 \end{cfa}
 Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}).
 …
 In the following example, \R{red} is the base type and \B{blue} is qualifiers.
 The \CFA declarations move the qualifiers to the left of the base type, \ie move the blue to the left of the red, while the qualifiers have the same meaning but are ordered left to right to specify a variable's type.
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 The only exception is \Index{bit field} specification, which always appear to the right of the base type.
 % Specifically, the character ©*© is used to indicate a pointer, square brackets ©[©\,©]© are used to represent an array or function return value, and parentheses ©()© are used to indicate a routine parameter.
 However, unlike C, \CFA type declaration tokens are distributed across all variables in the declaration list.
 For instance, variables ©x© and ©y© of type \Index{pointer} to integer are defined in \CFA as follows:
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 The downside of this semantics is the need to separate regular and \Index{pointer} declarations:
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 which is \Index{prescribing} a safety benefit.
 Other examples are:
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 All type qualifiers, \eg ©const©, ©volatile©, etc., are used in the normal way with the new declarations and also appear left to right, \eg:
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}}
 \multicolumn{1}{c@{\hspace{1em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}} \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 All declaration qualifiers, \eg ©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}} \eg:
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 The new declaration syntax can be used in other contexts where types are required, \eg casts and the pseudo-routine ©sizeof©:
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 y = (®* int®)x;
 i = sizeof(®[ 5 ] * int®);
+y = (* int)x;
+i = sizeof([ 5 ] * int);
 \end{cfa}
+&
 \begin{cfa}
 y = (®int *®)x;
 i = sizeof(®int * [ 5 ]®);
+y = (int *)x;
+i = sizeof(int * [ 5 ]);
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 Finally, new \CFA declarations may appear together with C declarations in the same program block, but cannot be mixed within a specific declaration.
 Therefore, a programmer has the option of either continuing to use traditional C declarations or take advantage of the new style.
+Clearly, both styles need to be supported for some time due to existing C-style header-files, particularly for UNIX systems.
+\section{Exponentiation Operator}
+C, \CC, and Java (and many other programming languages) have no exponentiation operator\index{exponentiation!operator}\index{operator!exponentiation}, \ie $x^y$, and instead use a routine, like \Indexc{pow}, to perform the exponentiation operation.
+\CFA extends the basic operators with the exponentiation operator ©?\?©\index{?\\?@\lstinline$?\?$} and ©?\=?©\index{?\\=?@\lstinline$?\=?$}, as in, ©x \ y© and ©x \= y©, which means $x^y$ and $x \leftarrow x^y$.
+The priority of the exponentiation operator is between the cast and multiplicative operators, so that ©w * (int)x \ (int)y * z© is parenthesized as ©((w * (((int)x) \ ((int)y))) * z)©.
+As for \Index{division}, there are exponentiation operators for integral and floating-point types, including the builtin \Index{complex} types.
+Unsigned integral exponentiation\index{exponentiation!unsigned integral} is performed with repeated multiplication\footnote{The multiplication computation is optimized to $O(\log y)$.} (or shifting if the base is 2).
+Signed integral exponentiation\index{exponentiation!signed integral} is performed with repeated multiplication (or shifting if the base is 2), but yields a floating-point result because $x^{-y}=1/x^y$.
+Hence, it is important to designate exponent integral-constants as unsigned or signed: ©3 \ 3u© return an integral result, while ©3 \ 3© returns a floating-point result.
+Floating-point exponentiation\index{exponentiation!floating point} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the base cannot be negative.
+\begin{cfa}
+sout | 2 ®\® 8u | 4 ®\® 3u | -4 ®\® 3u | 4 ®\® -3 | -4 ®\® -3 | 4.0 ®\® 2.1 | (1.0f+2.0fi) ®\® (3.0f+2.0fi) | endl;
+64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
+\end{cfa}
+Parenthesis are necessary for the complex constants or the expresion is parsed as ©1.0f+(2.0fi \ 3.0f)+2.0fi©.
+The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation versions are available.
+For returning an integral value, the user type ©T© must define multiplication, ©*©, and one, ©1©;
+for returning a floating-point value, an additional divide of type ©T© into a ©double© returning a ©double© (©double ?/?( double, T )©) is necessary for negative exponents.
+Clearly, both styles need to be supported for some time due to existing C-style header-files, particularly for UNIX-like systems.
 …
 A program \newterm{object} is a region of data storage in the execution environment, the contents of which can represent values.
 In most cases, objects are located in memory at an address, and the variable name for an object is an implicit address to the object generated by the compiler and automatically dereferenced, as in:
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}ll@{\hspace{2em}}l@{}}
 \begin{cfa}
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 where the right example is how the compiler logically interprets the variables in the left example.
 Since a variable name only points to one address during its lifetime, it is an \Index{immutable} \Index{pointer};
 …
 In general, variable addresses are stored in instructions instead of loaded from memory, and hence may not occupy storage.
 These approaches are contrasted in the following:
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l|l@{}}
 \multicolumn{1}{c|}{explicit variable address} & \multicolumn{1}{c}{implicit variable address} \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 Finally, the immutable nature of a variable's address and the fact that there is no storage for the variable pointer means pointer assignment\index{pointer!assignment}\index{assignment!pointer} is impossible.
 Therefore, the expression ©x = y© has only one meaning, ©*x = *y©, \ie manipulate values, which is why explicitly writing the dereferences is unnecessary even though it occurs implicitly as part of \Index{instruction decoding}.
 …
 (Similarly, an integer variable can contain multiple integer literals during its lifetime versus an integer constant representing a single literal during its lifetime, and like a variable name, may not occupy storage if the literal is embedded directly into instructions.)
 Hence, a pointer occupies memory to store its current address, and the pointer's value is loaded by dereferencing, \eg:
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{2em}}l@{}}
 \begin{cfa}
 …
 \raisebox{-0.5\totalheight}{\input{pointer2.pstex_t}}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 Notice, an address has a \Index{duality}\index{address!duality}: a location in memory or the value at that location.
 …
 The position of the ©const© qualifier \emph{after} the pointer/reference qualifier causes confuse for C programmers.
 The ©const© qualifier cannot be moved before the pointer/reference qualifier for C style-declarations;
 \CFA-style declarations (see \VRef{s:Declarations}) attempt to address this issue:
 \begin{quote2}
+\CFA-style declarations (see \VRef{s:AlternativeDeclarations}) attempt to address this issue:
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 where the \CFA declaration is read left-to-right.
 …
 \begin{cfa}
 void f( int i );
 void (*fp)( int );                                      §\C{// routine pointer}§
+void (* fp)( int );                                     §\C{// routine pointer}§
 fp = f;                                                         §\C{// reference initialization}§
 fp = &f;                                                        §\C{// pointer initialization}§
 …
 \end{cfa}
 This syntax allows a prototype declaration to be created by cutting and pasting source text from the routine definition header (or vice versa).
 Like C, it is possible to declare multiple routine-prototypes in a single declaration, where the return type is distributed across \emph{all} routine names in the declaration list (see~\VRef{s:Declarations}), \eg:
+Like C, it is possible to declare multiple routine-prototypes in a single declaration, where the return type is distributed across \emph{all} routine names in the declaration list (see~\VRef{s:AlternativeDeclarations}), \eg:
 \begin{cfa}
 C :             const double bar1(), bar2( int ), bar3( double );
 …
 Default arguments and overloading (see Section 24) are complementary.
 While in theory default arguments can be simulated with overloading, as in:
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{default arguments}}   & \multicolumn{1}{c}{\textbf{overloading}}      \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 the number of required overloaded routines is linear in the number of default values, which is unacceptable growth.
 In general, overloading should only be used over default arguments if the body of the routine is significantly different.
 …
 The following program in undefined in \CFA (and Indexc{gcc})
 \begin{cfa}
 [* [int]( int )] foo() {                §\C{// int (*foo())( int )}§
+[* [int]( int )] foo() {                §\C{// int (* foo())( int )}§
         int ®i® = 7;
         int bar( int p ) {
 …
+}
 int main() {
         * [int]( int ) fp = foo();      §\C{// int (*fp)( int )}§
+        * [int]( int ) fp = foo();      §\C{// int (* fp)( int )}§
         sout | fp( 3 ) | endl;
+}
 …
 In the latter approach, additional return values are passed as pointer parameters.
 A pointer parameter is assigned inside the routine to emulate a return.
 For example, consider C's \Indexc{modf} function, which returns the integral and fractional part of a floating-point value.
+For example, consider C's \Indexc{modf} function, which returns the integral and fractional part of a floating value.
 \begin{cfa}
 double modf( double x, double * i );            §\C{// from include math.h}§
 …
 The common case is printing out a sequence of variables separated by whitespace.
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{\CC}}      \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 The \CFA form has half the characters of the \CC form, and is similar to \Index*{Python} I/O with respect to implicit separators.
 Similar simplification occurs for \Index{tuple} I/O, which prints all tuple values separated by ``\lstinline[showspaces=true]@, @''.
 …
 Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority overloadable operator, other than assignment.
 Therefore, fewer output expressions require parenthesis.
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}ll@{}}
 \textbf{\CFA:}
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 There is a weak similarity between the \CFA logical-or operator and the Shell pipe-operator for moving data, where data flows in the correct direction for input but the opposite direction for output.
 …
         int id;
         float size;
         Parts *optionalParts;
+        Parts * optionalParts;
 };
 …
 Auto type-inferencing occurs in a declaration where a variable's type is inferred from its initialization ex\-pression type.
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{3em}}ll@{}}
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CC}} & \multicolumn{1}{c}{\textbf{\Indexc{gcc}}} \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 The two important capabilities are:
 \begin{itemize}
 …
 generic(type T)
 typedef int (*predicate)(T);
+typedef int (* predicate)(T);
 generic(type Captured, type T)
 typedef void (*callback)(Captured, T);
+typedef void (* callback)(Captured, T);
 generic(type T)
 void find(int length, T *array,
+void find(int length, T * array,
         predicate(T) p, callback(void *, T)f) {
         int i;
 …
 struct LinkedListElem {
         T elem;
         LinkedListElem(T) *next;
+        LinkedListElem(T) * next;
 };
 LinkedListElem *++?(LinkedListElem **elem) {
         return *elem = elem->next;
+LinkedListElem *++?(LinkedListElem ** elem) {
+        return * elem = elem->next;
+}
 generic (type T)
 struct LinkedList {
         LinkedListElem(T) *head;
+        LinkedListElem(T) * head;
         unsigned int size;
+}
 generic (type T | bool ?==?(T, T))
 bool contains(LinkedList(T) *list, T elem) {
         for(LinkedListElem *iter = list->head; iter != 0; ++iter) {
+bool contains(LinkedList(T) * list, T elem) {
+        for(LinkedListElem * iter = list->head; iter != 0; ++iter) {
         if (iter->elem == elem) return true;
+        }
 …
 // transferring requires mutual exclusion and calls deleteJob
 void transferJob(mutex Worker &from, Worker &to) {
+void transferJob(mutex Worker & from, Worker & to) {
         ...
         deleteJob(j);
 …
 #include <unistd.h>
+}
 size_t fileSize( const char *path ) {
+size_t fileSize( const char * path ) {
         struct stat s;
         stat(path, &s);
 …
 #[link(name = "libc")]
 extern {
         fn stat(path: *const u8,
         buf: *mut stat_t) -> c_int;
+}
 fn fileSize(path: *const u8) -> size_t
+        fn stat(path: * const u8,
+        buf: * mut stat_t) -> c_int;
+}
+fn fileSize(path: * const u8) -> size_t
+{
         unsafe {
 …
 generic(type T, type N |
         { int ?<?(N, N); })
 T *maximize(N (*f)(const T&),
+T * maximize(N (*f)(const T&),
         int n, T *a) {
         T *bestX = NULL;
+        T * bestX = NULL;
         N bestN;
         for (int i = 0; i < n; i++) {
 …
+}
 string *longest(int n, string *p)
+string * longest(int n, string *p)
+{
         return maximize(length, n, p);
 …
 \begin{cfa}
 template<typename T, typename F>
 T *maximize(const F &f,
+T * maximize(const F &f,
         int n, T *a) {
         typedef decltype(f(a[0])) N;
         T *bestX = NULL;
+        T * bestX = NULL;
         N bestN;
         for (int i = 0; i < n; i++) {
 …
+}
 string *longest(int n, string *p) {
+string * longest(int n, string *p) {
         return maximize(
         [](const string &s) {
 …
 \begin{cfa}
 task Nonzero {
         int *data;
+        int * data;
         int start;
         int end;
 …
 \CFA introduces the following new keywords.
 \begin{quote2}
+\begin{cquote}
 \input{../refrat/keywords}
 \end{quote2}
+\end{cquote}
 …
 \Celeven prescribes the following standard header-files~\cite[\S~7.1.2]{C11} and \CFA adds to this list:
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}llllll|l@{}}
 \multicolumn{6}{c|}{C11} & \multicolumn{1}{c}{\CFA}             \\
 …
 \end{tabular}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 For the prescribed head-files, \CFA uses header interposition to wraps these includes in an ©extern "C"©;
 hence, names in these include files are not mangled\index{mangling!name} (see~\VRef{s:Interoperability}).
 …
 The following factorial programs contrast using GMP with the \CFA and C interfaces, where the output from these programs appears in \VRef[Figure]{f:MultiPrecisionFactorials}.
 (Compile with flag \Indexc{-lgmp} to link with the GMP library.)
 \begin{quote2}
+\begin{cquote}
 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}}
 \multicolumn{1}{c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}}    & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}      \\
 …
 \end{cfa}
 \end{tabular}
 \end{quote2}
+\end{cquote}
 \begin{figure}

src/CodeGen/FixMain.cc

rc71b256	r7c782af
39	39	{
40	40	if(main_signature) {
41		throw SemanticError(~~"Multiple definition of main routine\n", functionDecl~~);
	41	throw SemanticError(functionDecl, "Multiple definition of main routine\n");
42	42	}
43	43	main_signature.reset( functionDecl->clone() );

src/CodeGen/FixNames.cc

rc71b256	r7c782af
118	118	int nargs = functionDecl->get_functionType()->get_parameters().size();
119	119	if( !(nargs == 0 \|\| nargs == 2 \|\| nargs == 3) ) {
120		throw SemanticError(~~"Main expected to have 0, 2 or 3 arguments\n", functionDecl~~);
	120	throw SemanticError(functionDecl, "Main expected to have 0, 2 or 3 arguments\n");
121	121	}
122	122	functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( new ConstantExpr( Constant::from_int( 0 ) ) ) );

src/Common/PassVisitor.impl.h

-              rc71b256
+              r7c782af
                         maybeAccept_impl( *i, visitor );
                 } catch( SemanticError &e ) {
-                        e.set_location( (*i)->location );
                         errors.append( e );
+                }
 …
                         maybeMutate_impl( *i, mutator );
                 } catch( SemanticError &e ) {
-                        e.set_location( (*i)->location );
                         errors.append( e );
+                }
 …
+                        }
                 } catch( SemanticError &e ) {
-                        e.set_location( (*i)->location );
                         errors.append( e );
+                }
 …
                         } // if
                 } catch( SemanticError &e ) {
-                        e.set_location( (*i)->location );
                         errors.append( e );
                 } // try
 …
                 } catch ( SemanticError &e ) {
-                        e.set_location( (*i)->location );
                         errors.append( e );
+                }

src/Common/SemanticError.cc

rc71b256	r7c782af
23	23	#include "SemanticError.h"
24	24
25		SemanticError::SemanticError() {
26		}
27
28		SemanticError::SemanticError( std::string error ) {
29		append( error );
	25	SemanticError::SemanticError( CodeLocation location, std::string error ) {
	26	append( location, error );
30	27	}
31	28
…	…
34	31	}
35	32
36		void SemanticError::append( const std::string & msg ) {
37		errors.emplace_back( ~~error_str() +~~ msg );
	33	void SemanticError::append( CodeLocation location, const std::string & msg ) {
	34	errors.emplace_back( location, msg );
38	35	}
39	36
…	…
42	39	}
43	40
44		void SemanticError::print( ~~std::ostream &os~~ ) {
	41	void SemanticError::print() {
45	42	using std::to_string;
46	43	for( auto err : errors ) {
47		~~os << err.location~~ << err.description << std::endl;
	44	std::cerr << bold() << err.location << error_str() << reset_font() << err.description << std::endl;
48	45	}
49	46	}
50	47
51		~~void SemanticError::set_location( const CodeLocation& location~~ ) {
52		~~errors.begin()->maybeSet( location )~~;
	48	SemanticWarning::SemanticWarning( CodeLocation location, std::string msg ) {
	49	std::cerr << bold() << location << warning_str() << reset_font() << msg << std::endl;
53	50	}
54	51

src/Common/SemanticError.h

-              rc71b256
+              r7c782af
 #include "CodeLocation.h"                                                               // for CodeLocation, toString
+//-----------------------------------------------------------------------------
+// Errors
 struct error {
+        CodeLocation location;
         std::string description;
-        CodeLocation location;
         error() = default;
+        error( const std::string & str ) : description( str ) {}
+        void maybeSet( const CodeLocation & location ) {
+                if( this->location.isUnset() ) {
+                        this->location = location;
+                }
+        }
+        error( CodeLocation loc, const std::string & str ) : location( loc ), description( str ) {}
 };
 class SemanticError : public std::exception {
   public:
+        SemanticError();
+        SemanticError( std::string error );
+        template< typename T > SemanticError( const std::string & error, const T * obj );
+        SemanticError() = default;
+        SemanticError( CodeLocation location, std::string error );
         ~SemanticError() throw() {}
+        // constructs an exception using the given message and the printed representation of the obj (T must have a print method)
+        template< typename T > SemanticError(const T * obj, const std::string & error);
+        template< typename T > SemanticError( CodeLocation location, const T * obj, const std::string & error);
         static inline const std::string & error_str() {
 …
         void append( SemanticError & other );
         void append( const std::string & );
+        void append( CodeLocation location, const std::string & );
         bool isEmpty() const;
+        void print( std::ostream & os );
+        void set_location( const CodeLocation & location );
+        // constructs an exception using the given message and the printed representation of the obj (T must have a print
+        // method)
+        void print();
   private:
         std::list< error > errors;
 …
 template< typename T >
+SemanticError::SemanticError( const std::string & error, const T * obj ) {
+        append( toString( error, obj ) );
+SemanticError::SemanticError( const T * obj, const std::string & error )
+        : SemanticError( obj->location, toString( error, obj ) )
+{}
+template< typename T >
+SemanticError::SemanticError( CodeLocation location, const T * obj, const std::string & error )
+        : SemanticError( location, toString( error, obj ) )
+{}
+//-----------------------------------------------------------------------------
+// Warnings
+class SemanticWarning {
+  public:
+        SemanticWarning( CodeLocation location, std::string error );
+        ~SemanticWarning() throw() {}
+        // constructs an exception using the given message and the printed representation of the obj (T must have a print method)
+        template< typename T > SemanticWarning(const T * obj, const std::string & error);
+        template< typename T > SemanticWarning( CodeLocation location, const T * obj, const std::string & error);
+        static inline const std::string & warning_str() {
+                static std::string str = isatty( STDERR_FILENO ) ? "\e[95mwarning:\e[39m " : "warning: ";
+                return str;
+        }
+  private:
+};
+template< typename T >
+SemanticWarning::SemanticWarning( const T * obj, const std::string & error )
+        : SemanticWarning( obj->location, toString( error, obj ) )
+{}
+template< typename T >
+SemanticWarning::SemanticWarning( CodeLocation location, const T * obj, const std::string & error )
+        : SemanticWarning( location, toString( error, obj ) )
+{}
+//-----------------------------------------------------------------------------
+// Helpers
+static inline const std::string & bold_ttycode() {
+        static std::string str = isatty( STDERR_FILENO ) ? "\e[1m" : "";
+        return str;
+}
+static inline const std::string & reset_font_ttycode() {
+        static std::string str = isatty( STDERR_FILENO ) ? "\e[0m" : "";
+        return str;
+}
+static inline std::string make_bold( const std::string & str ) {
+        return bold_ttycode() + str + reset_font_ttycode();
+}
+struct bold {};
+static inline std::ostream & operator<<(std::ostream & os, bold) {
+        os << bold_ttycode();
+        return os;
+}
+struct reset_font {};
+static inline std::ostream & operator<<(std::ostream & os, reset_font) {
+        os << reset_font_ttycode();
+        return os;
+}

src/Concurrency/Keywords.cc

-              rc71b256
+              r7c782af
                         handle( decl );
+                }
+        }
 …
                 if( ! decl->body ) return;
                 if( !type_decl ) throw SemanticError( context_error, decl );
+                if( !type_decl ) throw SemanticError( decl, context_error );
                 FunctionDecl * func = forwardDeclare( decl );
 …
                 if( mutexArgs.empty() ) return;
                 if( CodeGen::isConstructor(decl->name) ) throw SemanticError( "constructors cannot have mutex parameters", decl );
+                if( CodeGen::isConstructor(decl->name) ) throw SemanticError( decl, "constructors cannot have mutex parameters" );
                 bool isDtor = CodeGen::isDestructor( decl->name );
                 if( isDtor && mutexArgs.size() != 1 ) throw SemanticError( "destructors can only have 1 mutex argument", decl );
+                if( isDtor && mutexArgs.size() != 1 ) throw SemanticError( decl, "destructors can only have 1 mutex argument" );
                 for(auto arg : mutexArgs) {
 …
                 if( ! body ) return;
                 if( !monitor_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
                 if( !guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
                 if( !dtor_guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
+                if( !monitor_decl ) throw SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" );
+                if( !guard_decl ) throw SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" );
+                if( !dtor_guard_decl ) throw SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" );
                 if( isDtor ) {
 …
                 //Makes sure it's not a copy
                 ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
                 if( ! rty ) throw SemanticError( "Mutex argument must be of reference type ", arg );
+                if( ! rty ) throw SemanticError( arg, "Mutex argument must be of reference type " );
                 //Make sure the we are pointing directly to a type
                 Type* base = rty->get_base();
                 if( dynamic_cast< ReferenceType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
                 if( dynamic_cast< PointerType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
+                if( dynamic_cast< ReferenceType * >( base ) ) throw SemanticError( arg, "Mutex argument have exactly one level of indirection " );
+                if( dynamic_cast< PointerType * >( base ) ) throw SemanticError( arg, "Mutex argument have exactly one level of indirection " );
                 //Make sure that typed isn't mutex
                 if( base->get_mutex() ) throw SemanticError( "mutex keyword may only appear once per argument ", arg );
+                if( base->get_mutex() ) throw SemanticError( arg, "mutex keyword may only appear once per argument " );
+        }
 …
                 if( type && type->get_baseStruct()->is_thread() ) {
                         if( !thread_decl || !thread_ctor_seen ) {
                                 throw SemanticError("thread keyword requires threads to be in scope, add #include <thread>");
+                                throw SemanticError( type->get_baseStruct()->location, "thread keyword requires threads to be in scope, add #include <thread>");
+                        }

src/Concurrency/Waitfor.cc

-              rc71b256
+              r7c782af
         Statement * GenerateWaitForPass::postmutate( WaitForStmt * waitfor ) {
+                if( !decl_monitor || !decl_acceptable || !decl_mask ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor );
+                if( !decl_monitor || !decl_acceptable || !decl_mask )
+                        throw SemanticError( waitfor, "waitfor keyword requires monitors to be in scope, add #include <monitor>" );
                 CompoundStmt * stmt = new CompoundStmt();

src/ControlStruct/ExceptTranslate.cc

-              rc71b256
+              r7c782af
                         // Pass.
                 } else if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
                         throw SemanticError("catch must have exception type");
+                        throw SemanticError(catchStmt->location, "catch must have exception type");
                 } else {
                         throw SemanticError("catchResume must have exception type");
+                        throw SemanticError(catchStmt->location, "catchResume must have exception type");
+                }

src/ControlStruct/LabelFixer.cc

-              rc71b256
+              r7c782af
                         } else if ( labelTable[ l ]->defined() ) {
                                 // defined twice, error
                                 throw SemanticError( "Duplicate definition of label: " + l.get_name() );
+                                throw SemanticError( l.get_statement()->location, "Duplicate definition of label: " + l.get_name() );
                         }       else {
                                 // used previously, but undefined until now -> link with this entry
 …
                 for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
                         if ( ! i->second->defined() ) {
                                 throw SemanticError( "Use of undefined label: " + i->first.get_name() );
+                                throw SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() );
+                        }
                         (*ret)[ i->first ] = i->second->get_definition();

src/ControlStruct/MLEMutator.cc

-              rc71b256
+              r7c782af
                                         } else {
                                                 // break target is outmost control structure
                                                 if ( enclosingControlStructures.empty() ) throw SemanticError( "'break' outside a loop, switch, or labelled block" );
+                                                if ( enclosingControlStructures.empty() ) throw SemanticError( branchStmt->location, "'break' outside a loop, switch, or labelled block" );
                                                 targetEntry = enclosingControlStructures.rbegin();
                                         } // if
 …
                                 // ensure that selected target is valid
                                 if ( targetEntry == enclosingControlStructures.rend() || (isContinue && ! isLoop( targetEntry->get_controlStructure() ) ) ) {
                                         throw SemanticError( toString( (isContinue ? "'continue'" : "'break'"), " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "), originalTarget ) );
+                                        throw SemanticError( branchStmt->location, toString( (isContinue ? "'continue'" : "'break'"), " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "), originalTarget ) );
                                 } // if
                                 break;

src/GenPoly/Box.cc

-              rc71b256
+              r7c782af
                                 } // if
                         } catch( SemanticError &e ) {
-                                e.set_location( (*i)->location );
                                 errors.append( e );
                         } // try
 …
+                                                }
                                         } else {
                                                 throw SemanticError( "Cannot pass non-struct type for generic struct: ", argBaseType );
+                                                throw SemanticError( argBaseType, "Cannot pass non-struct type for generic struct: " );
+                                        }
+                                }
 …
                                         } else {
                                                 // xxx - should this be an assertion?
                                                 throw SemanticError( toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ), appExpr );
+                                                throw SemanticError( appExpr, toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ) );
                                         } // if
                                 } // if

src/InitTweak/FixInit.cc

-              rc71b256
+              r7c782af
                                         translationUnit.splice( i, fixer.pass.staticDtorDecls );
                                 } catch( SemanticError &e ) {
-                                        e.set_location( (*i)->location );
                                         errors.append( e );
                                 } // try
 …
+                        )
                         if ( ! diff.empty() ) {
                                 throw SemanticError( std::string("jump to label '") + stmt->get_target().get_name() + "' crosses initialization of " + (*diff.begin())->get_name() + " ", stmt );
+                                throw SemanticError( stmt, std::string("jump to label '") + stmt->get_target().get_name() + "' crosses initialization of " + (*diff.begin())->get_name() + " " );
                         } // if
                         // S_G-S_L results in set of objects that must be destructed
 …
                 template< typename Visitor, typename... Params >
                 void error( Visitor & v, CodeLocation loc, const Params &... params ) {
+                        SemanticError err( toString( params... ) );
+                        err.set_location( loc );
+                        SemanticError err( loc, toString( params... ) );
                         v.errors.append( err );
+                }

src/InitTweak/GenInit.cc

-              rc71b256
+              r7c782af
                 if ( tryConstruct( objDecl ) && ( managedTypes.isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
                         // constructed objects cannot be designated
                         if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n", objDecl );
+                        if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( objDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
                         // constructed objects should not have initializers nested too deeply
                         if ( ! checkInitDepth( objDecl ) ) throw SemanticError( "Managed object's initializer is too deep ", objDecl );
+                        if ( ! checkInitDepth( objDecl ) ) throw SemanticError( objDecl, "Managed object's initializer is too deep " );
                         objDecl->set_init( genCtorInit( objDecl ) );

src/InitTweak/InitTweak.cc

rc71b256	r7c782af
225	225	// xxx - this shouldn't be an error, but need a way to
226	226	// terminate without creating output, so should catch this error
227		throw SemanticError( "unbalanced list initializers" );
	227	throw SemanticError( init->location, "unbalanced list initializers" );
228	228	}
229	229

src/Parser/DeclarationNode.cc

-              rc71b256
+              r7c782af
                                         dst->basictype = src->basictype;
                                 } else if ( src->basictype != DeclarationNode::NoBasicType )
                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: ", src );
+                                        throw SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: " );
                                 if ( dst->complextype == DeclarationNode::NoComplexType ) {
                                         dst->complextype = src->complextype;
                                 } else if ( src->complextype != DeclarationNode::NoComplexType )
                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: ", src );
+                                        throw SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: " );
                                 if ( dst->signedness == DeclarationNode::NoSignedness ) {
                                         dst->signedness = src->signedness;
                                 } else if ( src->signedness != DeclarationNode::NoSignedness )
                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: ", src );
+                                        throw SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: " );
                                 if ( dst->length == DeclarationNode::NoLength ) {
 …
                                         dst->length = DeclarationNode::LongLong;
                                 } else if ( src->length != DeclarationNode::NoLength )
                                         throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: ", src );
+                                        throw SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: " );
                         } // if
                         break;
 …
                         } // if
                 } catch( SemanticError &e ) {
-                        e.set_location( cur->location );
                         errors.append( e );
                 } // try
 …
                         } // if
                 } catch( SemanticError &e ) {
-                        e.set_location( cur->location );
                         errors.append( e );
                 } // try
 …
                         * out++ = cur->buildType();
                 } catch( SemanticError &e ) {
-                        e.set_location( cur->location );
                         errors.append( e );
                 } // try
 …
 Declaration * DeclarationNode::build() const {
         if ( ! error.empty() ) throw SemanticError( error + " in declaration of ", this );
+        if ( ! error.empty() ) throw SemanticError( this, error + " in declaration of " );
         if ( asmStmt ) {
 …
                 //    inline _Noreturn int i;                   // disallowed
                 if ( type->kind != TypeData::Function && funcSpecs.any() ) {
                         throw SemanticError( "invalid function specifier for ", this );
+                        throw SemanticError( this, "invalid function specifier for " );
                 } // if
                 return buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
 …
         //    inlne _Noreturn enum   E { ... };         // disallowed
         if ( funcSpecs.any() ) {
                 throw SemanticError( "invalid function specifier for ", this );
+                throw SemanticError( this, "invalid function specifier for " );
         } // if
         assertf( name, "ObjectDecl must a have name\n" );

src/Parser/ExpressionNode.cc

-              rc71b256
+              r7c782af
 Expression * build_field_name_FLOATING_FRACTIONconstant( const string & str ) {
         if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
+        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( yylloc, "invalid tuple index " + str );
         Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
         delete &str;
 …
 Expression * build_field_name_FLOATING_DECIMALconstant( const string & str ) {
         if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );
+        if ( str[str.size()-1] != '.' ) throw SemanticError( yylloc, "invalid tuple index " + str );
         Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
         delete &str;

src/Parser/LinkageSpec.cc

-              rc71b256
+              r7c782af
 namespace LinkageSpec {
 Spec linkageCheck( const string * spec ) {
+Spec linkageCheck( CodeLocation location, const string * spec ) {
         assert( spec );
         unique_ptr<const string> guard( spec ); // allocated by lexer
 …
                 return BuiltinC;
         } else {
                 throw SemanticError( "Invalid linkage specifier " + *spec );
+                throw SemanticError( location, "Invalid linkage specifier " + *spec );
         } // if
+}
 Spec linkageUpdate( Spec old_spec, const string * cmd ) {
+Spec linkageUpdate( CodeLocation location, Spec old_spec, const string * cmd ) {
         assert( cmd );
         unique_ptr<const string> guard( cmd ); // allocated by lexer
 …
                 return old_spec;
         } else {
                 throw SemanticError( "Invalid linkage specifier " + *cmd );
+                throw SemanticError( location, "Invalid linkage specifier " + *cmd );
         } // if
+}

src/Parser/LinkageSpec.h

-              rc71b256
+              r7c782af
 #include <string>
+#include "Common/CodeLocation.h"
 namespace LinkageSpec {
 …
         Spec linkageCheck( const std::string * );
+        Spec linkageCheck( CodeLocation location, const std::string * );
         // Returns the Spec with the given name (limited to C, Cforall & BuiltinC)
         Spec linkageUpdate( Spec old_spec, const std::string * cmd );
+        Spec linkageUpdate( CodeLocation location, Spec old_spec, const std::string * cmd );
         /* If cmd = "C" returns a Spec that is old_spec with is_mangled = false
          * If cmd = "Cforall" returns old_spec Spec with is_mangled = true

src/Parser/ParseNode.h

rc71b256	r7c782af
434	434	} // if
435	435	} catch( SemanticError &e ) {
436		~~e.set_location( cur->location );~~
437	436	errors.append( e );
438	437	} // try

src/Parser/TypeData.cc

-              rc71b256
+              r7c782af
 using namespace std;
 TypeData::TypeData( Kind k ) : kind( k ), base( nullptr ), forall( nullptr ) /*, PTR1( (void*)(0xdeadbeefdeadbeef)), PTR2( (void*)(0xdeadbeefdeadbeef) ) */ {
+TypeData::TypeData( Kind k ) : location( yylloc ), kind( k ), base( nullptr ), forall( nullptr ) /*, PTR1( (void*)(0xdeadbeefdeadbeef)), PTR2( (void*)(0xdeadbeefdeadbeef) ) */ {
         switch ( kind ) {
           case Unknown:
 …
 static string genTSError( string msg, DeclarationNode::BasicType basictype ) {
         throw SemanticError( string( "invalid type specifier \"" ) + msg + "\" for type \"" + DeclarationNode::basicTypeNames[basictype] + "\"." );
+        throw SemanticError( yylloc, string( "invalid type specifier \"" ) + msg + "\" for type \"" + DeclarationNode::basicTypeNames[basictype] + "\"." );
 } // genTSError
 …
         assert( td->base );
         if ( td->symbolic.isTypedef ) {
                 ret = new TypedefDecl( name, scs, typebuild( td->base ), linkage );
+                ret = new TypedefDecl( name, td->location, scs, typebuild( td->base ), linkage );
         } else {
                 ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Dtype, true );
 …
                                 // type set => parameter name already transformed by a declaration names so there is a duplicate
                                 // declaration name attempting a second transformation
                                 if ( param->type ) throw SemanticError( string( "duplicate declaration name " ) + *param->name );
+                                if ( param->type ) throw SemanticError( param->location, string( "duplicate declaration name " ) + *param->name );
                                 // declaration type reset => declaration already transformed by a parameter name so there is a duplicate
                                 // parameter name attempting a second transformation
                                 if ( ! decl->type ) throw SemanticError( string( "duplicate parameter name " ) + *param->name );
+                                if ( ! decl->type ) throw SemanticError( param->location, string( "duplicate parameter name " ) + *param->name );
                                 param->type = decl->type;                               // set copy declaration type to parameter type
                                 decl->type = nullptr;                                   // reset declaration type
 …
                 } // for
                 // declaration type still set => type not moved to a matching parameter so there is a missing parameter name
                 if ( decl->type ) throw SemanticError( string( "missing name in parameter list " ) + *decl->name );
+                if ( decl->type ) throw SemanticError( decl->location, string( "missing name in parameter list " ) + *decl->name );
         } // for

src/Parser/TypeData.h

rc71b256	r7c782af
76	76	};
77	77
	78	CodeLocation location;
	79
78	80	Kind kind;
79	81	TypeData * base;

src/Parser/parser.yy

-              rc71b256
+              r7c782af
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Dec 21 11:32:56 2017
 // Update Count     : 2996
+// Last Modified On : Thu Feb 15 17:12:31 2018
+// Update Count     : 3006
 //
 …
                 { $$ = new ExpressionNode( new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >($2) ) ) ); }
         | type_name '.' no_attr_identifier                                      // CFA, nested type
                 { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; }                                                          // FIX ME
+                { throw SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; } // FIX ME
         | type_name '.' '[' push field_list pop ']'                     // CFA, nested type / tuple field selector
+                { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; }                                                          // FIX ME
+                { throw SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; } // FIX ME
+        | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
+                { throw SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; } // FIX ME
+        ;
+generic_assoc_list:                                                                             // C11
+        | generic_association
+        | generic_assoc_list ',' generic_association
+        ;
+generic_association:                                                                    // C11
+        type_no_function ':' assignment_expression
+        | DEFAULT ':' assignment_expression
+        ;
 …
         | unary_expression assignment_operator assignment_expression
                 { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
+        | unary_expression '=' '{' initializer_list comma_opt '}' // FIX ME
+                { $$ = nullptr; }
+        ;
 …
         | RETURN comma_expression_opt ';'
                 { $$ = new StatementNode( build_return( $2 ) ); }
+        | RETURN '{' initializer_list comma_opt '}'                     // FIX ME
+                { $$ = nullptr; }
         | THROW assignment_expression_opt ';'                           // handles rethrow
                 { $$ = new StatementNode( build_throw( $2 ) ); }
 …
 mutex_statement:
         MUTEX '(' argument_expression_list ')' statement
                 { throw SemanticError("Mutex statement is currently unimplemented."); $$ = nullptr; } // FIX ME
+                { throw SemanticError( yylloc, "Mutex statement is currently unimplemented." ); $$ = nullptr; } // FIX ME
+        ;
 …
 static_assert:
         STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11
                 { throw SemanticError("Static assert is currently unimplemented."); $$ = nullptr; }     // FIX ME
+                { throw SemanticError( yylloc, "Static assert is currently unimplemented." ); $$ = nullptr; }   // FIX ME
 // C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function
 …
+                {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
                         linkage = LinkageSpec::linkageUpdate( linkage, $2 );
+                        linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 );
+                }
           '{' external_definition_list_opt '}'

src/ResolvExpr/AlternativeFinder.cc

-              rc71b256
+              r7c782af
                                 std::cerr << "No reasonable alternatives for expression " << expr << std::endl;
+                        )
                         throw SemanticError( "No reasonable alternatives for expression ", expr );
+                        throw SemanticError( expr, "No reasonable alternatives for expression " );
+                }
                 if ( prune ) {
 …
                                 stream << "Alternatives are:\n";
                                 printAlts( winners, stream, 1 );
                                 throw SemanticError( stream.str() );
+                                throw SemanticError( expr->location, stream.str() );
+                        }
                         alternatives = move(pruned);
 …
                                 return;
                         } else if ( level >= recursionLimit ) {
                                 throw SemanticError( "Too many recursive assertions" );
+                                throw SemanticError( newAlt.expr->location, "Too many recursive assertions" );
                         } else {
                                 AssertionSet newerNeed;
 …
                         findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) );
                         if ( winners.size() != 1 ) {
                                 throw SemanticError( "Ambiguous expression in sizeof operand: ", sizeofExpr->get_expr() );
+                                throw SemanticError( sizeofExpr->get_expr(), "Ambiguous expression in sizeof operand: " );
                         } // if
                         // return the lowest cost alternative for the argument
 …
                         findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) );
                         if ( winners.size() != 1 ) {
                                 throw SemanticError( "Ambiguous expression in alignof operand: ", alignofExpr->get_expr() );
+                                throw SemanticError( alignofExpr->get_expr(), "Ambiguous expression in alignof operand: " );
                         } // if
                         // return the lowest cost alternative for the argument

src/ResolvExpr/CurrentObject.cc

-              rc71b256
+              r7c782af
                         base = at->get_base();
                         memberIter = createMemberIterator( base );
                         if ( at->isVarLen ) throw SemanticError( "VLA initialization does not support @=", at );
+                        if ( at->isVarLen ) throw SemanticError( at, "VLA initialization does not support @=" );
                         setSize( at->get_dimension() );
+                }
 …
                                         PRINT( std::cerr << "array type with size: " << size << std::endl; )
                                 } catch ( SemanticError & ) {
                                         throw SemanticError( "Constant expression of non-integral type in array dimension: ", expr );
+                                        throw SemanticError( expr, "Constant expression of non-integral type in array dimension: " );
+                                }
                         }       else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
 …
                                         index = constExpr->intValue();
                                 } catch( SemanticError & ) {
                                         throw SemanticError( "Constant expression of non-integral type in array designator: ", expr );
+                                        throw SemanticError( expr, "Constant expression of non-integral type in array designator: " );
+                                }
                         } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
 …
                 } // for
                 if ( desigAlts.size() > 1 ) {
                         throw SemanticError( toString("Too many alternatives (", desigAlts.size(), ") for designation: "), designation );
+                        throw SemanticError( designation, toString("Too many alternatives (", desigAlts.size(), ") for designation: ") );
                 } else if ( desigAlts.size() == 0 ) {
                         throw SemanticError( "No reasonable alternatives for designation: ", designation );
+                        throw SemanticError( designation, "No reasonable alternatives for designation: " );
+                }
                 DesignatorChain & d = desigAlts.back();

src/ResolvExpr/Resolver.cc

-              rc71b256
+              r7c782af
                         findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
                         if ( winners.size() == 0 ) {
                                 throw SemanticError( toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: "), untyped );
+                                throw SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") );
                         } else if ( winners.size() != 1 ) {
                                 std::ostringstream stream;
 …
                                 stream << "Alternatives are:\n";
                                 printAlts( winners, stream, 1 );
                                 throw SemanticError( stream.str() );
+                                throw SemanticError( untyped->location, stream.str() );
+                        }
 …
                         Alternative & choice = winners.front();
                         if ( findDeletedExpr( choice.expr ) ) {
                                 throw SemanticError( "Unique best alternative includes deleted identifier in ", choice.expr );
+                                throw SemanticError( choice.expr, "Unique best alternative includes deleted identifier in " );
+                        }
                         alt = std::move( choice );
 …
                                 ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name;
                                 ss << "' in call to waitfor";
                                 throw SemanticError( ss.str() );
+                                throw SemanticError( stmt->location, ss.str() );
+                        }
 …
                                         PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() );
                                         if( !pointer ) {
                                                 throw SemanticError( "candidate not viable: not a pointer type\n", func.expr->get_result() );
+                                                throw SemanticError( func.expr->get_result(), "candidate not viable: not a pointer type\n" );
+                                        }
                                         FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() );
                                         if( !function ) {
                                                 throw SemanticError( "candidate not viable: not a function type\n", pointer->get_base() );
+                                                throw SemanticError( pointer->get_base(), "candidate not viable: not a function type\n" );
+                                        }
 …
                                                 if( !advance_to_mutex( param, param_end ) ) {
                                                         throw SemanticError("candidate function not viable: no mutex parameters\n", function);
+                                                        throw SemanticError(function, "candidate function not viable: no mutex parameters\n");
+                                                }
+                                        }
 …
                                                                         // We ran out of parameters but still have arguments
                                                                         // this function doesn't match
                                                                         throw SemanticError("candidate function not viable: too many mutex arguments\n", function);
+                                                                        throw SemanticError( function, "candidate function not viable: too many mutex arguments\n" );
+                                                                }
 …
                                                                         (*param)->get_type()->print( ss );
                                                                         ss << "'\n";
                                                                         throw SemanticError(ss.str(), function);
+                                                                        throw SemanticError( function, ss.str() );
+                                                                }
 …
                                                                 // We ran out of arguments but still have parameters left
                                                                 // this function doesn't match
                                                                 throw SemanticError("candidate function not viable: too few mutex arguments\n", function);
+                                                                throw SemanticError( function, "candidate function not viable: too few mutex arguments\n" );
+                                                        }
 …
                         // Make sure we got the right number of arguments
                         if( func_candidates.empty() )    { SemanticError top( "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
                         if( args_candidates.empty() )    { SemanticError top( "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
                         if( func_candidates.size() > 1 ) { SemanticError top( "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
                         if( args_candidates.size() > 1 ) { SemanticError top( "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }
+                        if( func_candidates.empty() )    { SemanticError top( stmt->location, "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
+                        if( args_candidates.empty() )    { SemanticError top( stmt->location, "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
+                        if( func_candidates.size() > 1 ) { SemanticError top( stmt->location, "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
+                        if( args_candidates.size() > 1 ) { SemanticError top( stmt->location, "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }
                         // TODO: need to use findDeletedExpr to ensure no deleted identifiers are used.

src/SymTab/Indexer.cc

-              rc71b256
+              r7c782af
                         // isomorphic to C type-compatibility, which it may not be.
                         if ( hasIncompatibleCDecl( name, mangleName, scope ) ) {
                                 throw SemanticError( "conflicting overload of C function ", decl );
+                                throw SemanticError( decl, "conflicting overload of C function " );
+                        }
                 } else {
                         // Check that a Cforall declaration doesn't override any C declaration
                         if ( hasCompatibleCDecl( name, mangleName, scope ) ) {
                                 throw SemanticError( "Cforall declaration hides C function ", decl );
+                                throw SemanticError( decl, "Cforall declaration hides C function " );
+                        }
+                }
 …
         void Indexer::addId( DeclarationWithType * decl, Expression * baseExpr ) {
                 // default handling of conflicts is to raise an error
                 addId( decl, [decl](IdData &, const std::string & msg) { throw SemanticError( msg, decl ); return true; }, baseExpr );
+                addId( decl, [decl](IdData &, const std::string & msg) { throw SemanticError( decl, msg ); return true; }, baseExpr );
+        }
         void Indexer::addDeletedId( DeclarationWithType * decl, BaseSyntaxNode * deleteStmt ) {
                 // default handling of conflicts is to raise an error
                 addId( decl, [decl](IdData &, const std::string & msg) { throw SemanticError( msg, decl ); return true; }, nullptr, deleteStmt );
+                addId( decl, [decl](IdData &, const std::string & msg) { throw SemanticError( decl, msg ); return true; }, nullptr, deleteStmt );
+        }
 …
                         return true;
                 } else {
                         throw SemanticError( "redeclaration of ", added );
+                        throw SemanticError( added, "redeclaration of " );
+                }
+        }
 …
                         return false;
                 } else if ( ! added->get_members().empty() ) {
                         throw SemanticError( "redeclaration of ", added );
+                        throw SemanticError( added, "redeclaration of " );
                 } // if
                 return true;

src/SymTab/Validate.cc

-              rc71b256
+              r7c782af
                         // the only case in which "void" is valid is where it is the only one in the list
                         if ( containsVoid && ( nvals > 1 || isVarArgs ) ) {
                                 throw SemanticError( "invalid type void in function type ", func );
+                                throw SemanticError( func, "invalid type void in function type " );
+                        }
 …
                 for ( Expression * param : inst->parameters ) {
                         if ( ! dynamic_cast< TypeExpr * >( param ) ) {
                                 throw SemanticError( "Expression parameters for generic types are currently unsupported: ", inst );
+                                throw SemanticError( inst, "Expression parameters for generic types are currently unsupported: " );
+                        }
+                }
 …
                 TraitDecl *traitDecl = local_indexer->lookupTrait( traitInst->name );
                 if ( ! traitDecl ) {
                         throw SemanticError( "use of undeclared trait " + traitInst->name );
+                        throw SemanticError( traitInst->location, "use of undeclared trait " + traitInst->name );
                 } // if
                 if ( traitDecl->get_parameters().size() != traitInst->get_parameters().size() ) {
                         throw SemanticError( "incorrect number of trait parameters: ", traitInst );
+                        throw SemanticError( traitInst, "incorrect number of trait parameters: " );
                 } // if
                 traitInst->baseTrait = traitDecl;
 …
                         TypeExpr * expr = dynamic_cast< TypeExpr * >( std::get<1>(p) );
                         if ( ! expr ) {
                                 throw SemanticError( "Expression parameters for trait instances are currently unsupported: ", std::get<1>(p) );
+                                throw SemanticError( std::get<1>(p), "Expression parameters for trait instances are currently unsupported: " );
+                        }
                         if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) {
 …
                                 bool isVoid = fixFunction( assertion );
                                 if ( isVoid ) {
                                         throw SemanticError( "invalid type void in assertion of function ", node );
+                                        throw SemanticError( node, "invalid type void in assertion of function " );
                                 } // if
                         } // for
 …
                 // were cast to void.
                 if ( ! returnStmt->get_expr() && returnVals.size() != 0 ) {
                         throw SemanticError( "Non-void function returns no values: " , returnStmt );
+                        throw SemanticError( returnStmt, "Non-void function returns no values: " );
+                }
+        }
 …
                                 ReferenceToType *rtt = dynamic_cast<ReferenceToType*>(ret);
                                 if ( ! rtt ) {
                                         throw SemanticError("Cannot apply type parameters to base type of " + typeInst->name);
+                                        throw SemanticError( typeInst->location, "Cannot apply type parameters to base type of " + typeInst->name );
+                                }
                                 rtt->get_parameters().clear();
 …
                         Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base();
                         if ( ! ResolvExpr::typesCompatible( t1, t2, Indexer() ) ) {
                                 throw SemanticError( "Cannot redefine typedef: " + tyDecl->name );
+                                throw SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name );
+                        }
                         // Cannot redefine VLA typedefs. Note: this is slightly incorrect, because our notion of VLAs
 …
                         // to fix this corner case likely outweighs the utility of allowing it.
                         if ( isVariableLength( t1 ) || isVariableLength( t2 ) ) {
                                 throw SemanticError( "Cannot redefine typedef: " + tyDecl->name );
+                                throw SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name );
+                        }
                 } else {
 …
                                 type = new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() );
                         } // if
                         TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), Type::StorageClasses(), type, aggDecl->get_linkage() ) );
+                        TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), aggDecl->location, Type::StorageClasses(), type, aggDecl->get_linkage() ) );
                         typedefNames[ aggDecl->get_name() ] = std::make_pair( std::move( tyDecl ), scopeLevel );
                 } // if
 …
                 if ( CodeGen::isCtorDtorAssign( funcDecl->get_name() ) ) { // TODO: also check /=, etc.
                         if ( params.size() == 0 ) {
                                 throw SemanticError( "Constructors, destructors, and assignment functions require at least one parameter ", funcDecl );
+                                throw SemanticError( funcDecl, "Constructors, destructors, and assignment functions require at least one parameter " );
+                        }
                         ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() );
                         if ( ! refType ) {
                                 throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a reference ", funcDecl );
+                                throw SemanticError( funcDecl, "First parameter of a constructor, destructor, or assignment function must be a reference " );
+                        }
                         if ( CodeGen::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) {
                                 throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl );
+                                throw SemanticError( funcDecl, "Constructors and destructors cannot have explicit return values " );
+                        }
+                }
 …
                         sub.apply( inst );
                         if ( args.size() < params->size() ) throw SemanticError( "Too few type arguments in generic type ", inst );
                         if ( args.size() > params->size() ) throw SemanticError( "Too many type arguments in generic type ", inst );
+                        if ( args.size() < params->size() ) throw SemanticError( inst, "Too few type arguments in generic type " );
+                        if ( args.size() > params->size() ) throw SemanticError( inst, "Too many type arguments in generic type " );
+                }
+        }

src/SynTree/Declaration.h

-              rc71b256
+              r7c782af
         typedef NamedTypeDecl Parent;
   public:
+        TypedefDecl( const std::string &name, Type::StorageClasses scs, Type *type, LinkageSpec::Spec spec = LinkageSpec::Cforall ) : Parent( name, scs, type ) { set_linkage( spec ); }
+        TypedefDecl( const std::string &name, CodeLocation location, Type::StorageClasses scs, Type *type, LinkageSpec::Spec spec = LinkageSpec::Cforall )
+                : Parent( name, scs, type ) { set_linkage( spec ); this->location = location; }
         TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}

src/SynTree/Expression.cc

rc71b256	r7c782af
93	93	return 0;
94	94	}
95		throw SemanticError( ~~"Constant expression of non-integral type ", this~~ );
	95	throw SemanticError( this, "Constant expression of non-integral type " );
96	96	}
97	97

src/SynTree/Mutator.h

rc71b256	r7c782af
149	149	} // if
150	150	} catch( SemanticError &e ) {
151		~~e.set_location( (*i)->location );~~
152	151	errors.append( e );
153	152	} // try

src/SynTree/Statement.cc

rc71b256	r7c782af
100	100	//actually this is a syntactic error signaled by the parser
101	101	if ( type == BranchStmt::Goto && target.empty() ) {
102		throw SemanticError("goto without target");
	102	throw SemanticError( target.get_statement()->location, "goto without target");
103	103	}
104	104	}
…	…
107	107	Statement(), computedTarget( computedTarget ), type( type ) {
108	108	if ( type != BranchStmt::Goto \|\| computedTarget == nullptr ) {
109		throw SemanticError("Computed target not valid in branch statement");
	109	throw SemanticError( computedTarget->location, "Computed target not valid in branch statement");
110	110	}
111	111	}
…	…
203	203	CaseStmt::CaseStmt( Expression condition, const std::list<Statement > &statements, bool deflt ) throw ( SemanticError ) :
204	204	Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
205		if ( isDefault() && condition != 0 ) throw SemanticError(~~"default case with condition: ", condition~~);
	205	if ( isDefault() && condition != 0 ) throw SemanticError( condition, "default case with condition: " );
206	206	}
207	207

src/SynTree/TypeSubstitution.h

rc71b256	r7c782af
98	98	} // if
99	99	} else {
100		throw SemanticError( ~~toString( "Attempt to provide non-type parameter: ", toString( *actualIt ).c_str(), " for type parameter " ), formal~~ );
	100	throw SemanticError( formal, toString( "Attempt to provide non-type parameter: ", toString( *actualIt ).c_str(), " for type parameter " ) );
101	101	} // if
102	102	} else {

src/SynTree/Visitor.h

rc71b256	r7c782af
143	143	}
144	144	} catch( SemanticError &e ) {
145		~~e.set_location( (*i)->location );~~
146	145	errors.append( e );
147	146	}

src/libcfa/concurrency/alarm.c

-              rc71b256
+              r7c782af
 #include <stdio.h>
 #include <string.h>
-#include <time.h>
 #include <unistd.h>
 #include <sys/time.h>
 …
 #include "preemption.h"
-//=============================================================================================
-// time type
-//=============================================================================================
+#define one_second         1_000_000_000ul
+#define one_milisecond         1_000_000ul
+#define one_microsecond            1_000ul
+#define one_nanosecond                 1ul
+__cfa_time_t zero_time = { 0 };
+void ?{}( __cfa_time_t & this ) { this.val = 0; }
+void ?{}( __cfa_time_t & this, zero_t zero ) { this.val = 0; }
+void ?{}( itimerval & this, __cfa_time_t * alarm ) with( this ) {
+        it_value.tv_sec = alarm->val / one_second;                      // seconds
+        it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds
+static inline void ?{}( itimerval & this, __cfa_time_t * alarm ) with( this ) {
+        it_value.tv_sec = alarm->val / (1`cfa_s).val;                   // seconds
+        it_value.tv_usec = max( (alarm->val % (1`cfa_s).val) / (1`cfa_us).val, 1000 ); // microseconds
         it_interval.tv_sec = 0;
         it_interval.tv_usec = 0;
+}
+void ?{}( __cfa_time_t & this, timespec * curr ) {
+static inline void ?{}( __cfa_time_t & this, timespec * curr ) {
         uint64_t secs  = curr->tv_sec;
         uint64_t nsecs = curr->tv_nsec;
         this.val = (secs * one_second) + nsecs;
+        this.val = from_s(secs).val + nsecs;
+}
-__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs ) {
-        this.val = 0;
-        return this;
+}
-__cfa_time_t from_s ( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1_000_000_000ul; return ret; }
-__cfa_time_t from_ms( uint64_t val ) { __cfa_time_t ret; ret.val = val *     1_000_000ul; return ret; }
-__cfa_time_t from_us( uint64_t val ) { __cfa_time_t ret; ret.val = val *         1_000ul; return ret; }
-__cfa_time_t from_ns( uint64_t val ) { __cfa_time_t ret; ret.val = val *             1ul; return ret; }
 //=============================================================================================
 …
 //=============================================================================================
 void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) with( this ) {
+void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ) with( this ) {
         this.thrd = thrd;
         this.alarm = alarm;
 …
+}
 void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) with( this ) {
+void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ) with( this ) {
         this.proc = proc;
         this.alarm = alarm;

src/libcfa/concurrency/alarm.h

-              rc71b256
+              r7c782af
 #include <assert.h>
+#include "bits/cfatime.h"
 struct thread_desc;
 struct processor;
-struct timespec;
-struct itimerval;
-//=============================================================================================
-// time type
-//=============================================================================================
-struct __cfa_time_t {
-        uint64_t val;
-};
-// ctors
-void ?{}( __cfa_time_t & this );
-void ?{}( __cfa_time_t & this, zero_t zero );
-void ?{}( __cfa_time_t & this, timespec * curr );
-void ?{}( itimerval & this, __cfa_time_t * alarm );
-__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs );
-// logical ops
-static inline bool ?==?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val == rhs.val; }
-static inline bool ?!=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val != rhs.val; }
-static inline bool ?>? ( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val >  rhs.val; }
-static inline bool ?<? ( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val <  rhs.val; }
-static inline bool ?>=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val >= rhs.val; }
-static inline bool ?<=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val <= rhs.val; }
-static inline bool ?==?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val == rhs; }
-static inline bool ?!=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val != rhs; }
-static inline bool ?>? ( __cfa_time_t lhs, zero_t rhs ) { return lhs.val >  rhs; }
-static inline bool ?<? ( __cfa_time_t lhs, zero_t rhs ) { return lhs.val <  rhs; }
-static inline bool ?>=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val >= rhs; }
-static inline bool ?<=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val <= rhs; }
-// addition/substract
-static inline __cfa_time_t ?+?( __cfa_time_t lhs, __cfa_time_t rhs ) {
-        __cfa_time_t ret;
-        ret.val = lhs.val + rhs.val;
-        return ret;
+}
-static inline __cfa_time_t ?-?( __cfa_time_t lhs, __cfa_time_t rhs ) {
-        __cfa_time_t ret;
-        ret.val = lhs.val - rhs.val;
-        return ret;
+}
-__cfa_time_t from_s ( uint64_t );
-__cfa_time_t from_ms( uint64_t );
-__cfa_time_t from_us( uint64_t );
-__cfa_time_t from_ns( uint64_t );
-extern __cfa_time_t zero_time;
 //=============================================================================================
 …
 typedef alarm_node_t ** __alarm_it_t;
 void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
 void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
+void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s );
+void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s );
 void ^?{}( alarm_node_t & this );

src/libcfa/concurrency/coroutine.c

-              rc71b256
+              r7c782af
 // Wrapper for co
 void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
+        verify( preemption.enabled || this_processor->do_terminate );
         disable_interrupts();
 …
         enable_interrupts( __cfaabi_dbg_ctx );
+        verify( preemption.enabled || this_processor->do_terminate );
 } //ctxSwitchDirect

src/libcfa/concurrency/invoke.c

-              rc71b256
+              r7c782af
 extern void __suspend_internal(void);
 extern void __leave_coroutine(void);
+extern void __finish_creation(void);
 extern void __leave_thread_monitor( struct thread_desc * this );
 extern void disable_interrupts();
 …
         cor->state = Active;
+        enable_interrupts( __cfaabi_dbg_ctx );
         main( this );
 …
         // First suspend, once the thread arrives here,
         // the function pointer to main can be invalidated without risk
         __suspend_internal();
+        __finish_creation();
         // Fetch the thread handle from the user defined thread structure

src/libcfa/concurrency/kernel.c

-              rc71b256
+              r7c782af
 thread_local processor *      volatile this_processor;
+volatile thread_local bool preemption_in_progress = 0;
+volatile thread_local bool preemption_enabled = false;
+volatile thread_local unsigned short disable_preempt_count = 1;
+// volatile thread_local bool preemption_in_progress = 0;
+// volatile thread_local bool preemption_enabled = false;
+// volatile thread_local unsigned short disable_preempt_count = 1;
+volatile thread_local __cfa_kernel_preemption_data_t preemption = { false, false, 1 };
 //-----------------------------------------------------------------------------
 …
                         if(readyThread)
+                        {
                                 verify( !preemption_enabled );
+                                verify( !preemption.enabled );
                                 runThread(this, readyThread);
                                 verify( !preemption_enabled );
+                                verify( !preemption.enabled );
                                 //Some actions need to be taken from the kernel
 …
 void finishRunning(processor * this) with( this->finish ) {
         if( action_code == Release ) {
                 verify( !preemption_enabled );
+                verify( !preemption.enabled );
                 unlock( *lock );
+        }
 …
+        }
         else if( action_code == Release_Schedule ) {
                 verify( !preemption_enabled );
+                verify( !preemption.enabled );
                 unlock( *lock );
                 ScheduleThread( thrd );
+        }
         else if( action_code == Release_Multi ) {
                 verify( !preemption_enabled );
+                verify( !preemption.enabled );
                 for(int i = 0; i < lock_count; i++) {
                         unlock( *locks[i] );
 …
         this_coroutine = NULL;
         this_thread = NULL;
         preemption_enabled = false;
         disable_preempt_count = 1;
+        preemption.enabled = false;
+        preemption.disable_count = 1;
         // SKULLDUGGERY: We want to create a context for the processor coroutine
         // which is needed for the 2-step context switch. However, there is no reason
 …
+}
+void kernel_first_resume(processor * this) {
+        coroutine_desc * src = this_coroutine;
+        coroutine_desc * dst = get_coroutine(*this->runner);
+        verify( !preemption.enabled );
+        create_stack(&dst->stack, dst->stack.size);
+        CtxStart(this->runner, CtxInvokeCoroutine);
+        verify( !preemption.enabled );
+        dst->last = src;
+        dst->starter = dst->starter ? dst->starter : src;
+        // set state of current coroutine to inactive
+        src->state = src->state == Halted ? Halted : Inactive;
+        // set new coroutine that task is executing
+        this_coroutine = dst;
+        // SKULLDUGGERY normally interrupts are enable before leaving a coroutine ctxswitch.
+        // Therefore, when first creating a coroutine, interrupts are enable before calling the main.
+        // This is consistent with thread creation. However, when creating the main processor coroutine,
+        // we wan't interrupts to be disabled. Therefore, we double-disable interrupts here so they will
+        // stay disabled.
+        disable_interrupts();
+        // context switch to specified coroutine
+        assert( src->stack.context );
+        CtxSwitch( src->stack.context, dst->stack.context );
+        // when CtxSwitch returns we are back in the src coroutine
+        // set state of new coroutine to active
+        src->state = Active;
+        verify( !preemption.enabled );
+}
 //-----------------------------------------------------------------------------
 // Scheduler routines
 …
         verify( thrd->self_cor.state != Halted );
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 …
+        }
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
+}
 thread_desc * nextThread(cluster * this) with( *this ) {
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         lock( ready_queue_lock __cfaabi_dbg_ctx2 );
         thread_desc * head = pop_head( ready_queue );
         unlock( ready_queue_lock );
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         return head;
+}
 …
 void BlockInternal() {
         disable_interrupts();
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         returnToKernel();
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
+}
 …
         this_processor->finish.lock        = lock;
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         returnToKernel();
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
 …
         this_processor->finish.thrd        = thrd;
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         returnToKernel();
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
 …
         this_processor->finish.thrd        = thrd;
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         returnToKernel();
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
 …
         this_processor->finish.lock_count  = count;
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         returnToKernel();
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
 …
         this_processor->finish.thrd_count  = thrd_count;
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         returnToKernel();
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
 …
 void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
         verify( !preemption_enabled );
+        verify( !preemption.enabled );
         this_processor->finish.action_code = thrd ? Release_Schedule : Release;
         this_processor->finish.lock        = lock;
 …
 // Kernel boot procedures
 void kernel_startup(void) {
+        verify( !preemption.enabled );
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
 …
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made.
         resume( *mainProcessor->runner );
+        kernel_first_resume( this_processor );
 …
         __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
+        verify( !preemption.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
+        verify( preemption.enabled );
+}
 …
         __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
+        verify( preemption.enabled );
         disable_interrupts();
+        verify( !preemption.enabled );
         // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.

src/libcfa/concurrency/kernel_private.h

-              rc71b256
+              r7c782af
 extern thread_local processor *      volatile this_processor;
+extern volatile thread_local bool preemption_in_progress;
+extern volatile thread_local bool preemption_enabled;
+extern volatile thread_local unsigned short disable_preempt_count;
+// extern volatile thread_local bool preemption_in_progress;
+// extern volatile thread_local bool preemption_enabled;
+// extern volatile thread_local unsigned short disable_preempt_count;
+struct __cfa_kernel_preemption_data_t {
+        bool enabled;
+        bool in_progress;
+        unsigned short disable_count;
+};
+extern volatile thread_local __cfa_kernel_preemption_data_t preemption;
 //-----------------------------------------------------------------------------

src/libcfa/concurrency/monitor.c

-              rc71b256
+              r7c782af
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb  8 16:12:20 2018
 // Update Count     : 4
+// Last Modified On : Fri Feb 16 14:49:53 2018
+// Update Count     : 5
 //
 …
                 thread_desc * this_thrd = this_thread;
                 if ( this.monitor_count != this_thrd->monitors.size ) {
                         abort( "Signal on condition %p made with different number of monitor(s), expected %li got %li", &this, this.monitor_count, this_thrd->monitors.size );
+                        abort( "Signal on condition %p made with different number of monitor(s), expected %zi got %zi", &this, this.monitor_count, this_thrd->monitors.size );
+                }

src/libcfa/concurrency/preemption.c

-              rc71b256
+              r7c782af
         // Disable interrupts by incrementing the counter
         void disable_interrupts() {
                 preemption_enabled = false;
                 __attribute__((unused)) unsigned short new_val = disable_preempt_count + 1;
                 disable_preempt_count = new_val;
+                preemption.enabled = false;
+                __attribute__((unused)) unsigned short new_val = preemption.disable_count + 1;
+                preemption.disable_count = new_val;
                 verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
+        }
 …
                 thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
                 unsigned short prev = disable_preempt_count;
                 disable_preempt_count -= 1;
+                unsigned short prev = preemption.disable_count;
+                preemption.disable_count -= 1;
                 verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
                 // Check if we need to prempt the thread because an interrupt was missed
                 if( prev == 1 ) {
                         preemption_enabled = true;
+                        preemption.enabled = true;
                         if( proc->pending_preemption ) {
                                 proc->pending_preemption = false;
 …
         // Don't execute any pending CtxSwitch even if counter reaches 0
         void enable_interrupts_noPoll() {
                 unsigned short prev = disable_preempt_count;
                 disable_preempt_count -= 1;
+                unsigned short prev = preemption.disable_count;
+                preemption.disable_count -= 1;
                 verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
                 if( prev == 1 ) {
                         preemption_enabled = true;
+                        preemption.enabled = true;
+                }
+        }
 …
 // If false : preemption is unsafe and marked as pending
 static inline bool preemption_ready() {
         bool ready = preemption_enabled && !preemption_in_progress; // Check if preemption is safe
+        bool ready = preemption.enabled && !preemption.in_progress; // Check if preemption is safe
         this_processor->pending_preemption = !ready;                        // Adjust the pending flag accordingly
         return ready;
 …
         // Start with preemption disabled until ready
         preemption_enabled = false;
         disable_preempt_count = 1;
+        preemption.enabled = false;
+        preemption.disable_count = 1;
         // Initialize the event kernel
 …
 // Used by thread to control when they want to receive preemption signals
 void ?{}( preemption_scope & this, processor * proc ) {
         (this.alarm){ proc, zero_time, zero_time };
+        (this.alarm){ proc, 0`cfa_s, 0`cfa_s };
         this.proc = proc;
         this.proc->preemption_alarm = &this.alarm;
 …
         disable_interrupts();
         update_preemption( this.proc, zero_time );
+        update_preemption( this.proc, 0`cfa_s );
+}
 …
         __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
         preemption_in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
+        preemption.in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
         signal_unblock( SIGUSR1 );                          // We are about to CtxSwitch out of the signal handler, let other handlers in
         preemption_in_progress = false;                     // Clear the in progress flag
+        preemption.in_progress = false;                     // Clear the in progress flag
         // Preemption can occur here

src/libcfa/concurrency/thread.c

-              rc71b256
+              r7c782af
+}
+extern "C" {
+        void __finish_creation(void) {
+                coroutine_desc* thrd_c = this_coroutine;
+                ThreadCtxSwitch( thrd_c, thrd_c->last );
+        }
+}
 void yield( void ) {
+        verify( preemption.enabled );
         BlockInternal( this_thread );
+        verify( preemption.enabled );
+}

src/main.cc

-              rc71b256
+              r7c782af
                 } // if
+                CodeTools::fillLocations( translationUnit );
                 OPTPRINT( "resolve" )
                 ResolvExpr::resolve( translationUnit );
 …
                         cerr << endl << "---End of AST, begin error message:---\n" << endl;
                 } // if
                 e.print( cerr );
+                e.print();
                 if ( output != &cout ) {
                         delete output;

src/tests/.expect/alloc.txt

-              rc71b256
+              r7c782af
 CFA malloc 0xdeadbeef
 CFA alloc 0xdeadbeef
 CFA alloc, fill 01010101
+CFA alloc, fill ffffffff
 C   array calloc, fill 0
 …
 CFA array alloc, no fill
 xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
 CFA array alloc, fill 0x1
 x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
+CFA array alloc, fill 0xff
+xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff
 C   realloc
 …
 xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
 CFA resize array alloc, fill
 x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
+xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff
 CFA resize array alloc, fill
 x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
+xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff
 CFA resize array alloc, fill
 x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
+xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff
 C   memalign 42 42.5
 …
 CFA aligned_alloc 42 42.5
 CFA align_alloc 42 42.5
 CFA align_alloc fill 0x1010101 0x1.1010101010101p-1007
+CFA align_alloc fill 0xffffffff -nan
 CFA array align_alloc
 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5,
 CFA array align_alloc, fill
 x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007,
+xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan,
 CFA memset 0x1010101 0x1.1010101010101p-1007
 CFA memcpy 0x1010101 0x1.1010101010101p-1007
+CFA memset 0xffffffff -nan
+CFA memcpy 0xffffffff -nan
 CFA array memset
 x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007,
+xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan,
 CFA memcpy
 x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007,
+xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan,
 CFA new initialize

src/tests/alloc.c

-              rc71b256
+              r7c782af
 // Created On       : Wed Feb  3 07:56:22 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jan 22 21:26:40 2018
 // Update Count     : 326
+// Last Modified On : Fri Feb 16 15:42:31 2018
+// Update Count     : 330
 //
 …
 int main( void ) {
         size_t dim = 10;
+        char fill = '\xff';
         int * p;
-        char fill = '\1';
         // allocation, non-array types
 …
         p = alloc( 2 * dim, fill );                         // CFA array alloc, fill
         printf( "CFA array alloc, fill %#x\n", fill );
+        printf( "CFA array alloc, fill %#hhx\n", fill );
         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
         printf( "\n" );

src/tests/raii/.expect/dtor-early-exit-ERR2.txt

rc71b256	r7c782af
1		raii/dtor-early-exit.c:220:1 error: jump to label 'L2' crosses initialization of y Branch (Goto)
	1	raii/dtor-early-exit.c:217:1 error: jump to label 'L2' crosses initialization of y Branch (Goto)
2	2	with target: L2
3	3	with original target: L2

Context Navigation

Changes in / [c71b256:7c782af]

Legend:

Download in other formats: