Changeset bede27b

doc/papers/general/Makefile

r381fdee	rbede27b
18	18
19	19	FIGURES = ${addsuffix .tex, \
	20	Cdecl \
20	21	}
21	22

doc/papers/general/Paper.tex

-                      r381fdee
+                      rbede27b
 \usepackage{fullpage}
+\usepackage{epic,eepic}
 \usepackage{xspace,calc,comment}
 \usepackage{upquote}                                                                    % switch curled `'" to straight
 …
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \newcommand{\Textbf}[1]{{\color{red}\textbf{#1}}}
+\newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
 \newcommand{\TODO}[1]{\textbf{TODO}: {\itshape #1}} % TODO included
 %\newcommand{\TODO}[1]{} % TODO elided
 …
 \makeatother
+\newenvironment{cquote}{%
+        \list{}{\lstset{resetmargins=true,aboveskip=0pt,belowskip=0pt}\topsep=4pt\parsep=0pt\leftmargin=\parindent\rightmargin\leftmargin}%
+        \item\relax
+}{%
+        \endlist
+}% cquote
 % CFA programming language, based on ANSI C (with some gcc additions)
 \lstdefinelanguage{CFA}[ANSI]{C}{
 …
 int forty_two = identity( 42 );                         $\C{// T is bound to int, forty\_two == 42}$
 \end{lstlisting}
 The @identity@ function above can be applied to any complete \emph{object type} (or @otype@).
+The @identity@ function above can be applied to any complete \newterm{object type} (or @otype@).
 The type variable @T@ is transformed into a set of additional implicit parameters encoding sufficient information about @T@ to create and return a variable of that type.
 The \CFA implementation passes the size and alignment of the type represented by an @otype@ parameter, as well as an assignment operator, constructor, copy constructor and destructor.
 If this extra information is not needed, \eg for a pointer, the type parameter can be declared as a \emph{data type} (or @dtype@).
+If this extra information is not needed, \eg for a pointer, the type parameter can be declared as a \newterm{data type} (or @dtype@).
 In \CFA, the polymorphism runtime-cost is spread over each polymorphic call, due to passing more arguments to polymorphic functions;
 …
 A design advantage is that, unlike \CC template-functions, \CFA polymorphic-functions are compatible with C \emph{separate compilation}, preventing compilation and code bloat.
 Since bare polymorphic-types provide a restricted set of available operations, \CFA provides a \emph{type assertion}~\cite[pp.~37-44]{Alphard} mechanism to provide further type information, where type assertions may be variable or function declarations that depend on a polymorphic type-variable.
+Since bare polymorphic-types provide a restricted set of available operations, \CFA provides a \newterm{type assertion}~\cite[pp.~37-44]{Alphard} mechanism to provide further type information, where type assertions may be variable or function declarations that depend on a polymorphic type-variable.
 For example, the function @twice@ can be defined using the \CFA syntax for operator overloading:
 \begin{lstlisting}
 …
 \subsection{Traits}
 \CFA provides \emph{traits} to name a group of type assertions, where the trait name allows specifying the same set of assertions in multiple locations, preventing repetition mistakes at each function declaration:
+\CFA provides \newterm{traits} to name a group of type assertions, where the trait name allows specifying the same set of assertions in multiple locations, preventing repetition mistakes at each function declaration:
 \begin{lstlisting}
 trait summable( otype T ) {
 …
 Given the information provided for an @otype@, variables of polymorphic type can be treated as if they were a complete type: stack-allocatable, default or copy-initialized, assigned, and deleted.
 In summation, the \CFA type-system uses \emph{nominal typing} for concrete types, matching with the C type-system, and \emph{structural typing} for polymorphic types.
+In summation, the \CFA type-system uses \newterm{nominal typing} for concrete types, matching with the C type-system, and \newterm{structural typing} for polymorphic types.
 Hence, trait names play no part in type equivalence;
 the names are simply macros for a list of polymorphic assertions, which are expanded at usage sites.
 …
 Furthermore, writing and using preprocessor macros can be unnatural and inflexible.
 \CC, Java, and other languages use \emph{generic types} to produce type-safe abstract data-types.
+\CC, Java, and other languages use \newterm{generic types} to produce type-safe abstract data-types.
 \CFA also implements generic types that integrate efficiently and naturally with the existing polymorphic functions, while retaining backwards compatibility with C and providing separate compilation.
 However, for known concrete parameters, the generic-type definition can be inlined, like \CC templates.
 …
 \end{lstlisting}
 \CFA classifies generic types as either \emph{concrete} or \emph{dynamic}.
+\CFA classifies generic types as either \newterm{concrete} or \newterm{dynamic}.
 Concrete types have a fixed memory layout regardless of type parameters, while dynamic types vary in memory layout depending on their type parameters.
 A type may have polymorphic parameters but still be concrete, called \emph{dtype-static}.
+A type may have polymorphic parameters but still be concrete, called \newterm{dtype-static}.
 Polymorphic pointers are an example of dtype-static types, \eg @forall(dtype T) T *@ is a polymorphic type, but for any @T@, @T *@  is a fixed-sized pointer, and therefore, can be represented by a @void *@ in code generation.
 …
 Though \CFA implements concrete generic-types efficiently, it also has a fully general system for dynamic generic types.
 As mentioned in Section~\ref{sec:poly-fns}, @otype@ function parameters (in fact all @sized@ polymorphic parameters) come with implicit size and alignment parameters provided by the caller.
 Dynamic generic-types also have an \emph{offset array} containing structure-member offsets.
+Dynamic generic-types also have an \newterm{offset array} containing structure-member offsets.
 A dynamic generic-union needs no such offset array, as all members are at offset 0, but size and alignment are still necessary.
 Access to members of a dynamic structure is provided at runtime via base-displacement addressing with the structure pointer and the member offset (similar to the @offsetof@ macro), moving a compile-time offset calculation to runtime.
 …
 For instance, modularity is generally provided in C by including an opaque forward-declaration of a structure and associated accessor and mutator functions in a header file, with the actual implementations in a separately-compiled @.c@ file.
 \CFA supports this pattern for generic types, but the caller does not know the actual layout or size of the dynamic generic-type, and only holds it by a pointer.
 The \CFA translator automatically generates \emph{layout functions} for cases where the size, alignment, and offset array of a generic struct cannot be passed into a function from that function's caller.
+The \CFA translator automatically generates \newterm{layout functions} for cases where the size, alignment, and offset array of a generic struct cannot be passed into a function from that function's caller.
 These layout functions take as arguments pointers to size and alignment variables and a caller-allocated array of member offsets, as well as the size and alignment of all @sized@ parameters to the generic structure (un@sized@ parameters are forbidden from being used in a context that affects layout).
 Results of these layout functions are cached so that they are only computed once per type per function. %, as in the example below for @pair@.
 …
 Since @pair(T *, T * )@ is a concrete type, there are no implicit parameters passed to @lexcmp@, so the generated code is identical to a function written in standard C using @void *@, yet the \CFA version is type-checked to ensure the fields of both pairs and the arguments to the comparison function match in type.
 Another useful pattern enabled by reused dtype-static type instantiations is zero-cost \emph{tag-structures}.
+Another useful pattern enabled by reused dtype-static type instantiations is zero-cost \newterm{tag-structures}.
 Sometimes information is only used for type-checking and can be omitted at runtime, \eg:
 \begin{lstlisting}
 …
 The addition of multiple-return-value functions (MRVF) are useless without a syntax for accepting multiple values at the call-site.
 The simplest mechanism for capturing the return values is variable assignment, allowing the values to be retrieved directly.
 As such, \CFA allows assigning multiple values from a function into multiple variables, using a square-bracketed list of lvalue expressions (as above), called a \emph{tuple}.
 However, functions also use \emph{composition} (nested calls), with the direct consequence that MRVFs must also support composition to be orthogonal with single-returning-value functions (SRVF), \eg:
+As such, \CFA allows assigning multiple values from a function into multiple variables, using a square-bracketed list of lvalue expressions (as above), called a \newterm{tuple}.
+However, functions also use \newterm{composition} (nested calls), with the direct consequence that MRVFs must also support composition to be orthogonal with single-returning-value functions (SRVF), \eg:
 \begin{lstlisting}
 printf( "%d %d\n", div( 13, 5 ) );                      $\C{// return values seperated into arguments}$
 …
 printf( "%d %d\n", qr );
 \end{lstlisting}
 \CFA also supports \emph{tuple indexing} to access single components of a tuple expression:
+\CFA also supports \newterm{tuple indexing} to access single components of a tuple expression:
 \begin{lstlisting}
 [int, int] * p = &qr;                                           $\C{// tuple pointer}$
 …
 \subsection{Tuple Assignment}
 An assignment where the left side is a tuple type is called \emph{tuple assignment}.
 There are two kinds of tuple assignment depending on whether the right side of the assignment operator has a tuple type or a non-tuple type, called \emph{multiple} and \emph{mass assignment}, respectively.
+An assignment where the left side is a tuple type is called \newterm{tuple assignment}.
+There are two kinds of tuple assignment depending on whether the right side of the assignment operator has a tuple type or a non-tuple type, called \newterm{multiple} and \newterm{mass assignment}, respectively.
 %\lstDeleteShortInline@%
 %\par\smallskip
 …
 \subsection{Member Access}
 It is also possible to access multiple fields from a single expression using a \emph{member-access}.
+It is also possible to access multiple fields from a single expression using a \newterm{member-access}.
 The result is a single tuple-valued expression whose type is the tuple of the types of the members, \eg:
 \begin{lstlisting}
 …
 Matching against a @ttype@ parameter consumes all remaining argument components and packages them into a tuple, binding to the resulting tuple of types.
 In a given parameter list, there must be at most one @ttype@ parameter that occurs last, which matches normal variadic semantics, with a strong feeling of similarity to \CCeleven variadic templates.
 As such, @ttype@ variables are also called \emph{argument packs}.
+As such, @ttype@ variables are also called \newterm{argument packs}.
 Like variadic templates, the main way to manipulate @ttype@ polymorphic functions is via recursion.
 …
 \subsection{Implementation}
 Tuples are implemented in the \CFA translator via a transformation into \emph{generic types}.
+Tuples are implemented in the \CFA translator via a transformation into \newterm{generic types}.
 For each $N$, the first time an $N$-tuple is seen in a scope a generic type with $N$ type parameters is generated, \eg:
 \begin{lstlisting}
 …
 Similarly, tuple member expressions are recursively expanded into a list of member access expressions.
 Expressions that may contain side effects are made into \emph{unique expressions} before being expanded by the flattening conversion.
+Expressions that may contain side effects are made into \newterm{unique expressions} before being expanded by the flattening conversion.
 Each unique expression is assigned an identifier and is guaranteed to be executed exactly once:
 \begin{lstlisting}
 …
 \label{s:WithClauseStatement}
 Grouping heterogenous data into \newterm{aggregate}s is a common programming practice, and an aggregate can be further organized into more complex structures, such as arrays and containers:
 \begin{cfa}
 struct S {                                                              $\C{// aggregate}$
         char c;                                                         $\C{// fields}$
+Grouping heterogenous data into \newterm{aggregate}s (structure/union) is a common programming practice, and an aggregate can be further organized into more complex structures, such as arrays and containers:
+\begin{cfa}
+struct S {                                                                      $\C{// aggregate}$
+        char c;                                                                 $\C{// fields}$
         int i;
         double d;
 …
 S s, as[10];
 \end{cfa}
 However, routines manipulating aggregates have repeition of the aggregate name to access its containing fields:
+However, routines manipulating aggregates must repeat the aggregate name to access its containing fields:
 \begin{cfa}
 void f( S s ) {
         `s.`c; `s.`i; `s.`d;                            $\C{// access containing fields}$
+        `s.`c; `s.`i; `s.`d;                                    $\C{// access containing fields}$
+}
 \end{cfa}
 …
 \begin{C++}
 class C {
         char c;                                                         $\C{// fields}$
+        char c;                                                                 $\C{// fields}$
         int i;
         double d;
         int mem() {                                                     $\C{// implicit "this" parameter}$
                 `this->`c; `this->`i; `this->`d;$\C{// access containing fields}$
+        int mem() {                                                             $\C{// implicit "this" parameter}$
+                `this->`c; `this->`i; `this->`d;        $\C{// access containing fields}$
+        }
+}
 \end{C++}
+Nesting of member routines in a \lstinline[language=C++]@class@ allows eliding \lstinline[language=C++]@this->@ because of nested lexical-scoping.
+Nesting of member routines in a \lstinline[language=C++]@class@ allows eliding \lstinline[language=C++]@this->@ because of lexical scoping.
+However, for other aggregate parameters, qualification is necessary:
+\begin{cfa}
+struct T { double m, n; };
+int C::mem( T & t ) {                                           $\C{// multiple aggregate parameters}$
+        c; i; d;                                                                $\C{\color{red}// this-\textgreater.c, this-\textgreater.i, this-\textgreater.d}$
+        `t.`m; `t.`n;                                                   $\C{// must qualify}$
+}
+\end{cfa}
 % In object-oriented programming, there is an implicit first parameter, often names @self@ or @this@, which is elided.
 % In any programming language, some functions have a naturally close relationship with a particular data type.
 % Object-oriented programming allows this close relationship to be codified in the language by making such functions \emph{class methods} of their related data type.
 % Class methods have certain privileges with respect to their associated data type, notably un-prefixed access to the fields of that data type.
 % When writing C functions in an object-oriented style, this un-prefixed access is swiftly missed, as access to fields of a @Foo* f@ requires an extra three characters @f->@ every time, which disrupts coding flow and clutters the produced code.
+%
+% In any programming language, some functions have a naturally close relationship with a particular data type.
+% Object-oriented programming allows this close relationship to be codified in the language by making such functions \newterm{class methods} of their related data type.
+% Class methods have certain privileges with respect to their associated data type, notably un-prefixed access to the fields of that data type.
+% When writing C functions in an object-oriented style, this un-prefixed access is swiftly missed, as access to fields of a @Foo* f@ requires an extra three characters @f->@ every time, which disrupts coding flow and clutters the produced code.
+%
 % \TODO{Fill out section. Be sure to mention arbitrary expressions in with-blocks, recent change driven by Thierry to prioritize field name over parameters.}
 \CFA provides a @with@ clause/statement (see Pascal~\cite[\S~4.F]{Pascal}) to elided aggregate qualification to fields by opening a scope containing field identifiers.
 Hence, the qualified fields become variables, and making it easier to optimizing field references in a block.
 \begin{cfa}
 void f( S s ) `with s` {                                $\C{// with clause}$
         c; i; d;                                                        $\C{\color{red}// s.c, s.i, s.d}$
+To simplify the programmer experience, \CFA provides a @with@ clause/statement (see Pascal~\cite[\S~4.F]{Pascal}) to elide aggregate qualification to fields by opening a scope containing the field identifiers.
+Hence, the qualified fields become variables with the side-effect that it is easier to optimizing field references in a block.
+\begin{cfa}
+void f( S s ) `with( s )` {                                     $\C{// with clause}$
+        c; i; d;                                                                $\C{\color{red}// s.c, s.i, s.d}$
+}
 \end{cfa}
 and the equivalence for object-style programming is:
 \begin{cfa}
+int mem( S & this ) `with this` {               $\C{// with clause}$
+        c; i; d;                                                        $\C{\color{red}// this.c, this.i, this.d}$
+}
+\end{cfa}
+The key generality over the object-oriented approach is that one aggregate parameter \lstinline[language=C++]@this@ is not treated specially over other aggregate parameters:
+\begin{cfa}
+struct T { double m, n; };
+int mem( S & s, T & t ) `with s, t` {   $\C{// multiple aggregate parameters}$
+        c; i; d;                                                        $\C{\color{red}// s.c, s.i, s.d}$
+        m; n;                                                           $\C{\color{red}// t.m, t.n}$
+}
+\end{cfa}
+The equivalent object-oriented style is:
+\begin{cfa}
+int S::mem( T & t ) {                                   $\C{// multiple aggregate parameters}$
+        c; i; d;                                                        $\C{\color{red}// this-\textgreater.c, this-\textgreater.i, this-\textgreater.d}$
+        `t.`m; `t.`n;
+int mem( S & this ) `with( this )` {            $\C{// with clause}$
+        c; i; d;                                                                $\C{\color{red}// this.c, this.i, this.d}$
+}
+\end{cfa}
+with the generality of opening multiple aggregate-parameters:
+\begin{cfa}
+int mem( S & s, T & t ) `with( s, t )` {        $\C{// multiple aggregate parameters}$
+        c; i; d;                                                                $\C{\color{red}// s.c, s.i, s.d}$
+        m; n;                                                                   $\C{\color{red}// t.m, t.n}$
+}
+\end{cfa}
+In detail, the @with@ clause/statement has the form:
+\begin{cfa}
+$\emph{with-statement}$:
+        'with' '(' $\emph{expression-list}$ ')' $\emph{compound-statement}$
+\end{cfa}
+and may appear as the body of a routine or nested within a routine body.
+Each expression in the expression-list provides a type and object.
+The type must be an aggregate type.
+(Enumerations are already opened.)
+The object is the implicit qualifier for the open structure-fields.
+All expressions in the expression list are open in ``parallel'' within the compound statement.
+This semantic is different from Pascal, which nests the openings.
+The difference between parallel and nesting occurs for fields with the same name but different type:
+\begin{cfa}
+struct S { int i; int j; double m; } s, w;
+struct T { int i; int k; int m } t, w;
+with( s, t ) {
+        j + k;                                                                  $\C{// unambiguous, s.j + t.m}$
+        m = 5.0;                                                                $\C{// unambiguous, t.m = 5.0}$
+        m = 1;                                                                  $\C{// unambiguous, s.m = 1}$
+        int a = s.i + m;                                                $\C{// unambiguous, a = s.i + t.i}$
+        int b = s.i + t.i;                                              $\C{// unambiguous, qualification}$
+        sout | (double)m | endl;                                $\C{// unambiguous, cast}$
+        i;                                                                              $\C{// ambiguous}$
+}
+\end{cfa}
+\CFA's ability to overload variables means usages of field with the same names can be automatically disambiguated, eliminating most qualification.
+Qualification or a cast is used to disambiguate.
+A cast may be necessary to disambiguate between the overload variables in a @with@ expression:
+\begin{cfa}
+with( w ) { ... }                                                       $\C{// ambiguous, same name and no context}$
+with( (S)w ) { ... }                                            $\C{// unambiguous}$
+\end{cfa}
+\begin{cfa}
+struct S { int i, j; } sv;
+with( sv ) {
+        S & sr = sv;
+        with( sr ) {
+                S * sp = &sv;
+                with( *sp ) {
+                        i = 3; j = 4;                                   $\C{\color{red}// sp-{\textgreater}i, sp-{\textgreater}j}$
+                }
+                i = 3; j = 4;                                           $\C{\color{red}// sr.i, sr.j}$
+        }
+        i = 3; j = 4;                                                   $\C{\color{red}// sv.i, sv.j}$
+}
 \end{cfa}
 …
         struct S1 { ... } s1;
         struct S2 { ... } s2;
         `with s1` {                                             $\C{// with statement}$
+        `with( s1 )` {                                                  $\C{// with statement}$
                 // access fields of s1 without qualification
                 `with s2` {                                     $\C{// nesting}$
+                `with( s2 )` {                                          $\C{// nesting}$
                         // access fields of s1 and s2 without qualification
+                }
+        }
         `with s1, s2` {
+        `with( s1, s2 )` {
                 // access unambiguous fields of s1 and s2 without qualification
+        }
 …
 \end{cfa}
-When opening multiple structures, fields with the same name and type are ambiguous and must be fully qualified.
-For fields with the same name but different type, context/cast can be used to disambiguate.
-\begin{cfa}
-struct S { int i; int j; double m; } a, c;
-struct T { int i; int k; int m } b, c;
-`with a, b` {
-        j + k;                                                  $\C{// unambiguous, unique names define unique types}$
-        i;                                                              $\C{// ambiguous, same name and type}$
-        a.i + b.i;                                              $\C{// unambiguous, qualification defines unique names}$
-        m;                                                              $\C{// ambiguous, same name and no context to define unique type}$
-        m = 5.0;                                                $\C{// unambiguous, same name and context defines unique type}$
-        m = 1;                                                  $\C{// unambiguous, same name and context defines unique type}$
+}
-`with c` { ... }                                        $\C{// ambiguous, same name and no context}$
-`with (S)c` { ... }                                     $\C{// unambiguous, same name and cast defines unique type}$
-\end{cfa}
-The components in the "with" clause
-  with a, b, c { ... }
-serve 2 purposes: each component provides a type and object. The type must be a
-structure type. Enumerations are already opened, and I think a union is opened
-to some extent, too. (Or is that just unnamed unions?) The object is the target
-that the naked structure-fields apply to. The components are open in "parallel"
-at the scope of the "with" clause/statement, so opening "a" does not affect
-opening "b", etc. This semantic is different from Pascal, which nests the
-openings.
-Having said the above, it seems reasonable to allow a "with" component to be an
-expression. The type is the static expression-type and the object is the result
-of the expression. Again, the type must be an aggregate. Expressions require
-parenthesis around the components.
-  with( a, b, c ) { ... }
-Does this now make sense?
-Having written more CFA code, it is becoming clear to me that I *really* want
-the "with" to be implemented because I hate having to type all those object
-names for fields. It's a great way to drive people away from the language.
 \subsection{Exception Handling ???}
 …
 \section{Declarations}
 It is important to the design team that \CFA subjectively ``feel like'' C to user programmers.
 An important part of this subjective feel is maintaining C's procedural programming paradigm, as opposed to the object-oriented paradigm of other systems languages such as \CC and Rust.
 Maintaining this procedural paradigm means that coding patterns that work in C will remain not only functional but idiomatic in \CFA, reducing the mental burden of retraining C programmers and switching between C and \CFA development.
+It is important to the design team that \CFA subjectively ``feel like'' C to user programmers.
+An important part of this subjective feel is maintaining C's procedural programming paradigm, as opposed to the object-oriented paradigm of other systems languages such as \CC and Rust.
+Maintaining this procedural paradigm means that coding patterns that work in C will remain not only functional but idiomatic in \CFA, reducing the mental burden of retraining C programmers and switching between C and \CFA development.
 Nonetheless, some features of object-oriented languages are undeniably convienient, and the \CFA design team has attempted to adapt them to a procedural paradigm so as to incorporate their benefits into \CFA; two of these features are resource management and name scoping.
 …
 \subsection{Alternative Declaration Syntax}
+\newcommand{\R}[1]{\Textbf{#1}}
+\newcommand{\B}[1]{{\Textbf[blue]{#1}}}
+\newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}}
+C declaration syntax is notoriously confusing and error prone.
+For example, many C programmers are confused by a declaration as simple as:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}ll@{}}
+\begin{cfa}
+int * x[5]
+\end{cfa}
+&
+\raisebox{-0.75\totalheight}{\input{Cdecl}}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+Is this an array of 5 pointers to integers or a pointer to an array of 5 integers?
+If there is any doubt, it implies productivity and 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 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}$
+\end{cfa}
+Essentially, the return type is wrapped around the routine name in successive layers (like an onion).
+While attempting to make the two contexts consistent is a laudable goal, it has not worked out in practice.
+\CFA provides its own type, variable and routine declarations, using a different syntax.
+The new declarations place qualifiers to the left of the base type, while C declarations place qualifiers to the right of the base type.
+In the following example, \R{red} is 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{cquote}
+\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{cfa}
++[5] *+ `int` x1;
++* [5]+ `int` x2;
++[* [5] int]+ f`( int p )`;
+\end{cfa}
+&
+\begin{cfa}
+`int` +*+ x1 +[5]+;
+`int` +(*+x2+)[5]+;
++int (*+f`( int p )`+)[5]+;
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+The only exception is bit field specification, which always appear to the right of the base type.
+% Specifically, the character @*@ is used to indicate a pointer, square brackets @[@\,@]@ are used to represent an array or function return value, and parentheses @()@ are used to indicate a routine parameter.
+However, unlike C, \CFA type declaration tokens are distributed across all variables in the declaration list.
+For instance, variables @x@ and @y@ of type pointer to integer are defined in \CFA as follows:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
+\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+`*` int x, y;
+\end{cfa}
+&
+\begin{cfa}
+int `*`x, `*`y;
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+The downside of this semantics is the need to separate regular and pointer declarations:
+\begin{cquote}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
+\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
+\begin{cfa}
+`*` int x;
+int y;
+\end{cfa}
+&
+\begin{cfa}
+int `*`x, y;
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+which is prescribing a safety benefit.
+Other examples are:
+\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{cfa}
+[ 5 ] int z;
+[ 5 ] * char w;
+* [ 5 ] double v;
+struct s {
+        int f0:3;
+        * int f1;
+        [ 5 ] * int f2;
+};
+\end{cfa}
+&
+\begin{cfa}
+int z[ 5 ];
+char * w[ 5 ];
+double (* v)[ 5 ];
+struct s {
+        int f0:3;
+        int * f1;
+        int * f2[ 5 ]
+};
+\end{cfa}
+&
+\begin{cfa}
+// array of 5 integers
+// array of 5 pointers to char
+// pointer to array of 5 doubles
+// common bit field syntax
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\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{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{cfa}
+const * const int x;
+const * [ 5 ] const int y;
+\end{cfa}
+&
+\begin{cfa}
+int const * const x;
+const int (* const y)[ 5 ]
+\end{cfa}
+&
+\begin{cfa}
+// const pointer to const integer
+// const pointer to array of 5 const integers
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\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{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{cfa}
+extern [ 5 ] int x;
+static * const int y;
+\end{cfa}
+&
+\begin{cfa}
+int extern x[ 5 ];
+const int static * y;
+\end{cfa}
+&
+\begin{cfa}
+// externally visible array of 5 integers
+// internally visible pointer to constant int
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
+The new declaration syntax can be used in other contexts where types are required, \eg casts and the pseudo-routine @sizeof@:
+\begin{cquote}
+\lstDeleteShortInline@%
+\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);
+\end{cfa}
+&
+\begin{cfa}
+y = (int *)x;
+i = sizeof(int * [ 5 ]);
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\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-like systems.
 \subsection{References}
+All variables in C have an \emph{address}, a \emph{value}, and a \emph{type}; at the position in the program's memory denoted by the address, there exists a sequence of bits (the value), with the length and semantic meaning of this bit sequence defined by the type.
+The C type system does not always track the relationship between a value and its address; a value that does not have a corresponding address is called a \emph{rvalue} (for ``right-hand value''), while a value that does have an address is called a \emph{lvalue} (for ``left-hand value''); in @int x; x = 42;@ the variable expression @x@ on the left-hand-side of the assignment is a lvalue, while the constant expression @42@ on the right-hand-side of the assignment is a rvalue.
+Which address a value is located at is sometimes significant; the imperative programming paradigm of C relies on the mutation of values at specific addresses.
+Within a lexical scope, lvalue exressions can be used in either their \emph{address interpretation} to determine where a mutated value should be stored or in their \emph{value interpretation} to refer to their stored value; in @x = y;@ in @{ int x, y = 7; x = y; }@, @x@ is used in its address interpretation, while y is used in its value interpretation.
+Though this duality of interpretation is useful, C lacks a direct mechanism to pass lvalues between contexts, instead relying on \emph{pointer types} to serve a similar purpose.
+In C, for any type @T@ there is a pointer type @T*@, the value of which is the address of a value of type @T@; a pointer rvalue can be explicitly \emph{dereferenced} to the pointed-to lvalue with the dereference operator @*?@, while the rvalue representing the address of a lvalue can be obtained with the address-of operator @&?@.
+All variables in C have an \newterm{address}, a \newterm{value}, and a \newterm{type};
+at the position in the program's memory denoted by the address, there exists a sequence of bits (the value), with the length and semantic meaning of this bit sequence defined by the type.
+The C type-system does not always track the relationship between a value and its address;
+a value that does not have a corresponding address is called a \newterm{rvalue} (for ``right-hand value''), while a value that does have an address is called a \newterm{lvalue} (for ``left-hand value'').
+For example, in @int x; x = 42;@ the variable expression @x@ on the left-hand-side of the assignment is a lvalue, while the constant expression @42@ on the right-hand-side of the assignment is a rvalue.
+In imperative programming, the address of a value is used for both reading and writing (mutating) a value.
+Within a lexical scope, lvalue expressions have an \newterm{address interpretation} for writing a value or a \newterm{value interpretation} to read a value.
+For example, in @x = y@, @x@ has an address interpretation, while @y@ has a value interpretation.
+Though this duality of interpretation is useful, C lacks a direct mechanism to pass lvalues between contexts, instead relying on \newterm{pointer types} to serve a similar purpose.
+In C, for any type @T@ there is a pointer type @T *@, the value of which is the address of a value of type @T@.
+A pointer rvalue can be explicitly \newterm{dereferenced} to the pointed-to lvalue with the dereference operator @*?@, while the rvalue representing the address of a lvalue can be obtained with the address-of operator @&?@.
 \begin{cfa}
 int x = 1, y = 2, * p1, * p2, ** p3;
+p1 = &x;  $\C{// p1 points to x}$
+p2 = &y;  $\C{// p2 points to y}$
+p3 = &p1;  $\C{// p3 points to p1}$
+\end{cfa}
+Unfortunately, the dereference and address-of operators introduce a great deal of syntactic noise when dealing with pointed-to values rather than pointers, as well as the potential for subtle bugs.
+It would be desirable to have the compiler figure out how to elide the dereference operators in a complex expression such as @*p2 = ((*p1 + *p2) * (**p3 - *p1)) / (**p3 - 15);@, for both brevity and clarity.
+However, since C defines a number of forms of \emph{pointer arithmetic}, two similar expressions involving pointers to arithmetic types (\eg @*p1 + x@ and @p1 + x@) may each have well-defined but distinct semantics, introducing the possibility that a user programmer may write one when they mean the other, and precluding any simple algorithm for elision of dereference operators.
+p1 = &x;                                                                $\C{// p1 points to x}$
+p2 = &y;                                                                $\C{// p2 points to y}$
+p3 = &p1;                                                               $\C{// p3 points to p1}$
+*p2 = ((*p1 + *p2) * (**p3 - *p1)) / (**p3 - 15);
+\end{cfa}
+Unfortunately, the dereference and address-of operators introduce a great deal of syntactic noise when dealing with pointed-to values rather than pointers, as well as the potential for subtle bugs.
+For both brevity and clarity, it would be desirable to have the compiler figure out how to elide the dereference operators in a complex expression such as the assignment to @*p2@ above.
+However, since C defines a number of forms of \newterm{pointer arithmetic}, two similar expressions involving pointers to arithmetic types (\eg @*p1 + x@ and @p1 + x@) may each have well-defined but distinct semantics, introducing the possibility that a user programmer may write one when they mean the other, and precluding any simple algorithm for elision of dereference operators.
 To solve these problems, \CFA introduces reference types @T&@; a @T&@ has exactly the same value as a @T*@, but where the @T*@ takes the address interpretation by default, a @T&@ takes the value interpretation by default, as below:
 \begin{cfa}
 inx x = 1, y = 2, & r1, & r2, && r3;
+int x = 1, y = 2, & r1, & r2, && r3;
 &r1 = &x;  $\C{// r1 points to x}$
 &r2 = &y;  $\C{// r2 points to y}$
 …
 \end{cfa}
 Except for auto-dereferencing by the compiler, this reference example is exactly the same as the previous pointer example.
 Hence, a reference behaves like a variable name -- an lvalue expression which is interpreted as a value, but also has the type system track the address of that value.
+Except for auto-dereferencing by the compiler, this reference example is exactly the same as the previous pointer example.
+Hence, a reference behaves like a variable name -- an lvalue expression which is interpreted as a value, but also has the type system track the address of that value.
 One way to conceptualize a reference is via a rewrite rule, where the compiler inserts a dereference operator before the reference variable for each reference qualifier in the reference variable declaration, so the previous example implicitly acts like:
 …
 \end{cfa}
+References in \CFA are similar to those in \CC, but with a couple important improvements, both of which can be seen in the example above.
+Firstly, \CFA does not forbid references to references, unlike \CC.
+This provides a much more orthogonal design for library implementors, obviating the need for workarounds such as @std::reference_wrapper@.
+Secondly, unlike the references in \CC which always point to a fixed address, \CFA references are rebindable.
+This allows \CFA references to be default-initialized (to a null pointer), and also to point to different addresses throughout their lifetime.
+This rebinding is accomplished without adding any new syntax to \CFA, but simply by extending the existing semantics of the address-of operator in C.
+In C, the address of a lvalue is always a rvalue, as in general that address is not stored anywhere in memory, and does not itself have an address.
+In \CFA, the address of a @T&@ is a lvalue @T*@, as the address of the underlying @T@ is stored in the reference, and can thus be mutated there.
+The result of this rule is that any reference can be rebound using the existing pointer assignment semantics by assigning a compatible pointer into the address of the reference, \eg @&r1 = &x;@ above.
+This rebinding can occur to an arbitrary depth of reference nesting; $n$ address-of operators applied to a reference nested $m$ times will produce an lvalue pointer nested $n$ times if $n \le m$ (note that $n = m+1$ is simply the usual C rvalue address-of operator applied to the $n = m$ case).
+The explicit address-of operators can be thought of as ``cancelling out'' the implicit dereference operators, \eg @(&`*`)r1 = &x@ or @(&(&`*`)`*`)r3 = &(&`*`)r1@ or even @(&`*`)r2 = (&`*`)`*`r3@ for @&r2 = &r3@.
+Since pointers and references share the same internal representation, code using either is equally performant; in fact the \CFA compiler converts references to pointers internally, and the choice between them in user code can be made based solely on convenience.
+References in \CFA are similar to those in \CC, but with a couple important improvements, both of which can be seen in the example above.
+Firstly, \CFA does not forbid references to references, unlike \CC.
+This provides a much more orthogonal design for library implementors, obviating the need for workarounds such as @std::reference_wrapper@.
+Secondly, unlike the references in \CC which always point to a fixed address, \CFA references are rebindable.
+This allows \CFA references to be default-initialized (\eg to a null pointer), and also to point to different addresses throughout their lifetime.
+This rebinding is accomplished without adding any new syntax to \CFA, but simply by extending the existing semantics of the address-of operator in C.
+In C, the address of a lvalue is always a rvalue, as in general that address is not stored anywhere in memory, and does not itself have an address.
+In \CFA, the address of a @T&@ is a lvalue @T*@, as the address of the underlying @T@ is stored in the reference, and can thus be mutated there.
+The result of this rule is that any reference can be rebound using the existing pointer assignment semantics by assigning a compatible pointer into the address of the reference, \eg @&r1 = &x;@ above.
+This rebinding can occur to an arbitrary depth of reference nesting; loosely speaking, nested address-of operators will produce an lvalue nested pointer up to as deep as the reference they're applied to.
+These explicit address-of operators can be thought of as ``cancelling out'' the implicit dereference operators, \eg @(&`*`)r1 = &x@ or @(&(&`*`)`*`)r3 = &(&`*`)r1@ or even @(&`*`)r2 = (&`*`)`*`r3@ for @&r2 = &r3@.
+More precisely:
+\begin{itemize}
+        \item
+        if @R@ is an rvalue of type {@T &@$_1 \cdots$@ &@$_r$} where $r \ge 1$ references (@&@ symbols) than @&R@ has type {@T `*`&@$_{\color{red}2} \cdots$@ &@$_{\color{red}r}$}, \\ \ie @T@ pointer with $r-1$ references (@&@ symbols).
+        \item
+        if @L@ is an lvalue of type {@T &@$_1 \cdots$@ &@$_l$} where $l \ge 0$ references (@&@ symbols) then @&L@ has type {@T `*`&@$_{\color{red}1} \cdots$@ &@$_{\color{red}l}$}, \\ \ie @T@ pointer with $l$ references (@&@ symbols).
+\end{itemize}
+Since pointers and references share the same internal representation, code using either is equally performant; in fact the \CFA compiler converts references to pointers internally, and the choice between them in user code can be made based solely on convenience.
 By analogy to pointers, \CFA references also allow cv-qualifiers:
 …
 \end{cfa}
+Given that a reference is meant to represent a lvalue, \CFA provides some syntactic shortcuts when initializing references.
+There are three initialization contexts in \CFA: declaration initialization, argument/parameter binding, and return/temporary binding.
+In each of these contexts, the address-of operator on the target lvalue may (in fact, must) be elided.
+The syntactic motivation for this is clearest when considering overloaded operator-assignment, \eg @int ?+=?(int &, int)@; given @int x, y@, the expected call syntax is @x += y@, not @&x += y@.
+This initialization of references from lvalues rather than pointers can be considered a ``lvalue-to-reference'' conversion rather than an elision of the address-of operator; similarly, use of a the value pointed to by a reference in an rvalue context can be thought of as a ``reference-to-rvalue'' conversion.
+\CFA includes one more reference conversion, an ``rvalue-to-reference'' conversion, implemented by means of an implicit temporary.
+When an rvalue is used to initialize a reference, it is instead used to initialize a hidden temporary value with the same lexical scope as the reference, and the reference is initialized to the address of this temporary.
+This allows complex values to be succinctly and efficiently passed to functions, without the syntactic overhead of explicit definition of a temporary variable or the runtime cost of pass-by-value.
+\CC allows a similar binding, but only for @const@ references; the more general semantics of \CFA are an attempt to avoid the \emph{const hell} problem, in which addition of a @const@ qualifier to one reference requires a cascading chain of added qualifiers.
+Given that a reference is meant to represent a lvalue, \CFA provides some syntactic shortcuts when initializing references.
+There are three initialization contexts in \CFA: declaration initialization, argument/parameter binding, and return/temporary binding.
+In each of these contexts, the address-of operator on the target lvalue may (in fact, must) be elided.
+The syntactic motivation for this is clearest when considering overloaded operator-assignment, \eg @int ?+=?(int &, int)@; given @int x, y@, the expected call syntax is @x += y@, not @&x += y@.
+More generally, this initialization of references from lvalues rather than pointers is an instance of a ``lvalue-to-reference'' conversion rather than an elision of the address-of operator; this conversion can actually be used in any context in \CFA an implicit conversion would be allowed.
+Similarly, use of a the value pointed to by a reference in an rvalue context can be thought of as a ``reference-to-rvalue'' conversion, and \CFA also includes a qualifier-adding ``reference-to-reference'' conversion, analogous to the @T *@ to @const T *@ conversion in standard C.
+The final reference conversion included in \CFA is ``rvalue-to-reference'' conversion, implemented by means of an implicit temporary.
+When an rvalue is used to initialize a reference, it is instead used to initialize a hidden temporary value with the same lexical scope as the reference, and the reference is initialized to the address of this temporary.
+This allows complex values to be succinctly and efficiently passed to functions, without the syntactic overhead of explicit definition of a temporary variable or the runtime cost of pass-by-value.
+\CC allows a similar binding, but only for @const@ references; the more general semantics of \CFA are an attempt to avoid the \newterm{const hell} problem, in which addition of a @const@ qualifier to one reference requires a cascading chain of added qualifiers.
 \subsection{Constructors and Destructors}
+One of the strengths of C is the control over memory management it gives programmers, allowing resource release to be more consistent and precisely timed than is possible with garbage-collected memory management.
+However, this manual approach to memory management is often verbose, and it is useful to manage resources other than memory (\eg file handles) using the same mechanism as memory.
+\CC is well-known for an approach to manual memory management that addresses both these issues, Resource Allocation Is Initialization (RAII), implemented by means of special \emph{constructor} and \emph{destructor} functions; we have implemented a similar feature in \CFA.
+\TODO{Fill out section. Mention field-constructors and at-equal escape hatch to C-style initialization. Probably pull some text from Rob's thesis for first draft.}
+One of the strengths of C is the control over memory management it gives programmers, allowing resource release to be more consistent and precisely timed than is possible with garbage-collected memory management.
+However, this manual approach to memory management is often verbose, and it is useful to manage resources other than memory (\eg file handles) using the same mechanism as memory.
+\CC is well-known for an approach to manual memory management that addresses both these issues, Resource Aquisition Is Initialization (RAII), implemented by means of special \newterm{constructor} and \newterm{destructor} functions; we have implemented a similar feature in \CFA.
+While RAII is a common feature of object-oriented programming languages, its inclusion in \CFA does not violate the design principle that \CFA retain the same procedural paradigm as C.
+In particular, \CFA does not implement class-based encapsulation: neither the constructor nor any other function has privileged access to the implementation details of a type, except through the translation-unit-scope method of opaque structs provided by C.
+In \CFA, a constructor is a function named @?{}@, while a destructor is a function named @^?{}@; like other \CFA operators, these names represent the syntax used to call the constructor or destructor, \eg @x{ ... };@ or @^x{};@.
+Every constructor and destructor must have a return type of @void@, and its first parameter must have a reference type whose base type is the type of the object the function constructs or destructs.
+This first parameter is informally called the @this@ parameter, as in many object-oriented languages, though a programmer may give it an arbitrary name.
+Destructors must have exactly one parameter, while constructors allow passing of zero or more additional arguments along with the @this@ parameter.
+\begin{cfa}
+struct Array {
+        int * data;
+        int len;
+};
+void ?{}( Array& arr ) {
+        arr.len = 10;
+        arr.data = calloc( arr.len, sizeof(int) );
+}
+void ^?{}( Array& arr ) {
+        free( arr.data );
+}
+{
+        Array x;
+        `?{}(x);`       $\C{// implicitly compiler-generated}$
+        // ... use x
+        `^?{}(x);`      $\C{// implicitly compiler-generated}$
+}
+\end{cfa}
+In the example above, a \newterm{default constructor} (\ie one with no parameters besides the @this@ parameter) and destructor are defined for the @Array@ struct, a dynamic array of @int@.
+@Array@ is an example of a \newterm{managed type} in \CFA, a type with a non-trivial constructor or destructor, or with a field of a managed type.
+As in the example, all instances of managed types are implicitly constructed upon allocation, and destructed upon deallocation; this ensures proper initialization and cleanup of resources contained in managed types, in this case the @data@ array on the heap.
+The exact details of the placement of these implicit constructor and destructor calls are omitted here for brevity, the interested reader should consult \cite{Schluntz17}.
+Constructor calls are intended to seamlessly integrate with existing C initialization syntax, providing a simple and familiar syntax to veteran C programmers and allowing constructor calls to be inserted into legacy C code with minimal code changes.
+As such, \CFA also provides syntax for \newterm{copy initialization} and \newterm{initialization parameters}:
+\begin{cfa}
+void ?{}( Array& arr, Array other );
+void ?{}( Array& arr, int size, int fill );
+Array y = { 20, 0xDEADBEEF }, z = y;
+\end{cfa}
+Copy constructors have exactly two parameters, the second of which has the same type as the base type of the @this@ parameter; appropriate care is taken in the implementation to avoid recursive calls to the copy constructor when initializing this second parameter.
+Other constructor calls look just like C initializers, except rather than using field-by-field initialization (as in C), an initialization which matches a defined constructor will call the constructor instead.
+In addition to initialization syntax, \CFA provides two ways to explicitly call constructors and destructors.
+Explicit calls to constructors double as a placement syntax, useful for construction of member fields in user-defined constructors and reuse of large storage allocations.
+While the existing function-call syntax works for explicit calls to constructors and destructors, \CFA also provides a more concise \newterm{operator syntax} for both:
+\begin{cfa}
+Array a, b;
+a{};                            $\C{// default construct}$
+b{ a };                         $\C{// copy construct}$
+^a{};                           $\C{// destruct}$
+a{ 5, 0xFFFFFFFF };     $\C{// explicit constructor call}$
+\end{cfa}
+To provide a uniform type interface for @otype@ polymorphism, the \CFA compiler automatically generates a default constructor, copy constructor, assignment operator, and destructor for all types.
+These default functions can be overridden by user-generated versions of them.
+For compatibility with the standard behaviour of C, the default constructor and destructor for all basic, pointer, and reference types do nothing, while the copy constructor and assignment operator are bitwise copies; if default zero-initialization is desired, the default constructors can be overridden.
+For user-generated types, the four functions are also automatically generated.
+@enum@ types are handled the same as their underlying integral type, and unions are also bitwise copied and no-op initialized and destructed.
+For compatibility with C, a copy constructor from the first union member type is also defined.
+For @struct@ types, each of the four functions are implicitly defined to call their corresponding functions on each member of the struct.
+To better simulate the behaviour of C initializers, a set of \newterm{field constructors} is also generated for structures.
+A constructor is generated for each non-empty prefix of a structure's member-list which copy-constructs the members passed as parameters and default-constructs the remaining members.
+To allow users to limit the set of constructors available for a type, when a user declares any constructor or destructor, the corresponding generated function and all field constructors for that type are hidden from expression resolution; similarly, the generated default constructor is hidden upon declaration of any constructor.
+These semantics closely mirror the rule for implicit declaration of constructors in \CC\cite[p.~186]{ANSI98:C++}.
+In rare situations user programmers may not wish to have constructors and destructors called; in these cases, \CFA provides an ``escape hatch'' to not call them.
+If a variable is initialized using the syntax \lstinline|S x @= {}| it will be an \newterm{unmanaged object}, and will not have constructors or destructors called.
+Any C initializer can be the right-hand side of an \lstinline|@=| initializer, \eg  \lstinline|Array a @= { 0, 0x0 }|, with the usual C initialization semantics.
+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{Default Parameters}
 …
         TIMED( "copy_int", ti = si; )
         TIMED( "clear_int", clear( &si ); )
         REPEAT_TIMED( "pop_int", N,
+        REPEAT_TIMED( "pop_int", N,
                 int xi = pop( &ti ); if ( xi > maxi ) { maxi = xi; } )
         REPEAT_TIMED( "print_int", N/2, print( out, vali, ":", vali, "\n" ); )
 …
         TIMED( "copy_pair", tp = sp; )
         TIMED( "clear_pair", clear( &sp ); )
         REPEAT_TIMED( "pop_pair", N,
+        REPEAT_TIMED( "pop_pair", N,
                 pair(_Bool, char) xp = pop( &tp ); if ( xp > maxp ) { maxp = xp; } )
         REPEAT_TIMED( "print_pair", N/2, print( out, valp, ":", valp, "\n" ); )
 …
 Note, the C benchmark uses unchecked casts as there is no runtime mechanism to perform such checks, while \CFA and \CC provide type-safety statically.
 Figure~\ref{fig:eval} and Table~\ref{tab:eval} show the results of running the benchmark in Figure~\ref{fig:BenchmarkTest} and its C, \CC, and \CCV equivalents.
+Figure~\ref{fig:eval} and Table~\ref{tab:eval} show the results of running the benchmark in Figure~\ref{fig:BenchmarkTest} and its C, \CC, and \CCV equivalents.
 The graph plots the median of 5 consecutive runs of each program, with an initial warm-up run omitted.
 All code is compiled at \texttt{-O2} by GCC or G++ 6.2.0, with all \CC code compiled as \CCfourteen.
 …
 Finally, the binary size for \CFA is larger because of static linking with the \CFA libraries.
 \CFA is also competitive in terms of source code size, measured as a proxy for programmer effort. The line counts in Table~\ref{tab:eval} include implementations of @pair@ and @stack@ types for all four languages for purposes of direct comparison, though it should be noted that \CFA and \CC have pre-written data structures in their standard libraries that programmers would generally use instead. Use of these standard library types has minimal impact on the performance benchmarks, but shrinks the \CFA and \CC benchmarks to 73 and 54 lines, respectively.
+\CFA is also competitive in terms of source code size, measured as a proxy for programmer effort. The line counts in Table~\ref{tab:eval} include implementations of @pair@ and @stack@ types for all four languages for purposes of direct comparison, though it should be noted that \CFA and \CC have pre-written data structures in their standard libraries that programmers would generally use instead. Use of these standard library types has minimal impact on the performance benchmarks, but shrinks the \CFA and \CC benchmarks to 73 and 54 lines, respectively.
 On the other hand, C does not have a generic collections-library in its standard distribution, resulting in frequent reimplementation of such collection types by C programmers.
 \CCV does not use the \CC standard template library by construction, and in fact includes the definition of @object@ and wrapper classes for @bool@, @char@, @int@, and @const char *@ in its line count, which inflates this count somewhat, as an actual object-oriented language would include these in the standard library;
+\CCV does not use the \CC standard template library by construction, and in fact includes the definition of @object@ and wrapper classes for @bool@, @char@, @int@, and @const char *@ in its line count, which inflates this count somewhat, as an actual object-oriented language would include these in the standard library;
 with their omission, the \CCV line count is similar to C.
 We justify the given line count by noting that many object-oriented languages do not allow implementing new interfaces on library types without subclassing or wrapper types, which may be similarly verbose.
 …
 In addition, there are interesting future directions for the polymorphism design.
 Notably, \CC template functions trade compile time and code bloat for optimal runtime of individual instantiations of polymorphic functions.
 \CFA polymorphic functions use dynamic virtual-dispatch;
+\CFA polymorphic functions use dynamic virtual-dispatch;
 the runtime overhead of this approach is low, but not as low as inlining, and it may be beneficial to provide a mechanism for performance-sensitive code.
 Two promising approaches are an @inline@ annotation at polymorphic function call sites to create a template-specialization of the function (provided the code is visible) or placing an @inline@ annotation on polymorphic function-definitions to instantiate a specialized version for some set of types (\CC template specialization).

src/Common/PassVisitor.impl.h

-                      r381fdee
+                      rbede27b
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( WaitForStmt * node ) {
+        VISIT_BODY( node );
+        VISIT_START( node );
+        for( auto & clause : node->clauses ) {
+                maybeAccept_impl( clause.target.function, *this );
+                maybeAccept_impl( clause.target.arguments, *this );
+                maybeAccept_impl( clause.statement, *this );
+                maybeAccept_impl( clause.condition, *this );
+        }
+        maybeAccept_impl( node->timeout.time, *this );
+        maybeAccept_impl( node->timeout.statement, *this );
+        maybeAccept_impl( node->timeout.condition, *this );
+        maybeAccept_impl( node->orelse.statement, *this );
+        maybeAccept_impl( node->orelse.condition, *this );
+        VISIT_END( node );
+}
 template< typename pass_type >
 Statement * PassVisitor< pass_type >::mutate( WaitForStmt * node ) {
+        MUTATE_BODY( Statement, node );
+        MUTATE_START( node );
+        for( auto & clause : node->clauses ) {
+                maybeMutate_impl( clause.target.function, *this );
+                maybeMutate_impl( clause.target.arguments, *this );
+                maybeMutate_impl( clause.statement, *this );
+                maybeMutate_impl( clause.condition, *this );
+        }
+        maybeMutate_impl( node->timeout.time, *this );
+        maybeMutate_impl( node->timeout.statement, *this );
+        maybeMutate_impl( node->timeout.condition, *this );
+        maybeMutate_impl( node->orelse.statement, *this );
+        maybeMutate_impl( node->orelse.condition, *this );
+        MUTATE_END( Statement, node );
+}

src/GenPoly/Lvalue.cc

-                      r381fdee
+                      rbede27b
                                         return ret;
+                                }
+                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * > ( arg ) ) {
+                                // need to move cast to pointer type out a level since address of pointer
+                                // is not valid C code (can be introduced in prior passes, e.g., InstantiateGeneric)
+                                if ( InitTweak::getPointerBase( castExpr->result ) ) {
+                                        addrExpr->arg = castExpr->arg;
+                                        castExpr->arg = addrExpr;
+                                        castExpr->result = new PointerType( Type::Qualifiers(), castExpr->result );
+                                        return castExpr;
+                                }
+                        }
                         return addrExpr;

src/libcfa/bits/debug.c

-                      r381fdee
+                      rbede27b
 // Last Modified By :
 // Last Modified On :
 // Update Count     : 0
+// Update Count     : 1
 //
 …
         void __cfaabi_dbg_bits_release() __attribute__((__weak__)) {}
         void __cfaabi_dbg_bits_print_safe  ( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )) {
+        void __cfaabi_dbg_bits_print_safe  ( const char fmt[], ... ) __attribute__(( format(printf, 1, 2) )) {
                 va_list args;
 …
+        }
         void __cfaabi_dbg_bits_print_nolock( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )) {
+        void __cfaabi_dbg_bits_print_nolock( const char fmt[], ... ) __attribute__(( format(printf, 1, 2) )) {
                 va_list args;
 …
+        }
         void __cfaabi_dbg_bits_print_buffer( char in_buffer[], int in_buffer_size, const char fmt[], ... ) __attribute__(( format (printf, 3, 4) )) {
+        void __cfaabi_dbg_bits_print_buffer( char in_buffer[], int in_buffer_size, const char fmt[], ... ) __attribute__(( format(printf, 3, 4) )) {
                 va_list args;

src/libcfa/bits/debug.h

-                      r381fdee
+                      rbede27b
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 10:02:24 2017
 // Update Count     : 1
+// Last Modified On : Thu Feb  8 12:35:19 2018
+// Update Count     : 2
 //
 …
       extern void __cfaabi_dbg_bits_acquire();
       extern void __cfaabi_dbg_bits_release();
       extern void __cfaabi_dbg_bits_print_safe  ( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) ));
       extern void __cfaabi_dbg_bits_print_nolock( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) ));
+      extern void __cfaabi_dbg_bits_print_safe  ( const char fmt[], ... ) __attribute__(( format(printf, 1, 2) ));
+      extern void __cfaabi_dbg_bits_print_nolock( const char fmt[], ... ) __attribute__(( format(printf, 1, 2) ));
       extern void __cfaabi_dbg_bits_print_vararg( const char fmt[], va_list arg );
       extern void __cfaabi_dbg_bits_print_buffer( char buffer[], int buffer_size, const char fmt[], ... ) __attribute__(( format (printf, 3, 4) ));
+      extern void __cfaabi_dbg_bits_print_buffer( char buffer[], int buffer_size, const char fmt[], ... ) __attribute__(( format(printf, 3, 4) ));
 #ifdef __cforall
+}

src/libcfa/bits/defs.h

-                      r381fdee
+                      rbede27b
 //
+//
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 //
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
 //
 // defs.h --
 //
+//
+// defs.h --
+//
 // Author           : Thierry Delisle
 // Created On       : Thu Nov  9 13:24:10 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Jan  2 09:17:06 2018
 // Update Count     : 2
 //
+// Last Modified On : Thu Feb  8 16:22:41 2018
+// Update Count     : 8
+//
 #pragma once
 …
 #ifdef __cforall
+void abort ( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
 extern "C" {
 #endif
 void abortf( const char fmt[], ... ) __attribute__ ((__nothrow__, __leaf__, __noreturn__));
+void __cabi_abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
 #ifdef __cforall
+}

src/libcfa/concurrency/coroutine.c

-                      r381fdee
+                      rbede27b
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:34:57 2017
 // Update Count     : 1
+// Last Modified On : Thu Feb  8 16:10:31 2018
+// Update Count     : 4
 //
 …
                 __cfaabi_dbg_debug_do(
                         if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
                                 abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
+                                abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
+                        }
                 );
 …
                 __cfaabi_dbg_debug_do(
                         if ( mprotect( storage, pageSize, PROT_NONE ) == -1 ) {
                                 abortf( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) );
+                                abort( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) );
                         } // if
                 );
                 if ( (intptr_t)storage == 0 ) {
                         abortf( "Attempt to allocate %d bytes of storage for coroutine or task execution-state but insufficient memory available.", size );
+                        abort( "Attempt to allocate %zd bytes of storage for coroutine or task execution-state but insufficient memory available.", size );
                 } // if

src/libcfa/concurrency/invoke.c

-                      r381fdee
+                      rbede27b
 // Created On       : Tue Jan 17 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Feb  9 14:41:56 2018
 // Update Count     : 3
+// Last Modified On : Fri Feb  9 16:37:42 2018
+// Update Count     : 5
 //
 …
         //Final suspend, should never return
         __leave_coroutine();
         abortf("Resumed dead coroutine");
+        __cabi_abort( "Resumed dead coroutine" );
+}
 …
         //Final suspend, should never return
         __leave_thread_monitor( thrd );
         abortf("Resumed dead thread");
+        __cabi_abort( "Resumed dead thread" );
+}

src/libcfa/concurrency/kernel.c

r381fdee	rbede27b
168	168	if( ! do_terminate ) {
169	169	__cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
170		~~do_terminate = true~~;
	170	terminate(&this);
171	171	P( terminated );
172	172	pthread_join( kernel_thread, NULL );

src/libcfa/concurrency/kernel_private.h

r381fdee	rbede27b
60	60	void runThread(processor * this, thread_desc * dst);
61	61	void finishRunning(processor * this);
	62	void terminate(processor * this);
62	63	void spin(processor * this, unsigned int * spin_count);
63	64

src/libcfa/concurrency/monitor.c

-                      r381fdee
+                      rbede27b
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jul 31 14:59:05 2017
 // Update Count     : 3
+// Last Modified On : Thu Feb  8 16:12:20 2018
+// Update Count     : 4
 //
 …
                 thread_desc * thrd = this_thread;
                 __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
+                __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
                 if( !this->owner ) {
 …
                         set_owner( this, thrd );
                         __cfaabi_dbg_print_safe("Kernel :  mon is free \n");
+                        __cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
+                }
                 else if( this->owner == thrd) {
 …
                         this->recursion += 1;
                         __cfaabi_dbg_print_safe("Kernel :  mon already owned \n");
+                        __cfaabi_dbg_print_safe( "Kernel :  mon already owned \n" );
+                }
                 else if( is_accepted( this, group) ) {
 …
                         reset_mask( this );
                         __cfaabi_dbg_print_safe("Kernel :  mon accepts \n");
+                        __cfaabi_dbg_print_safe( "Kernel :  mon accepts \n" );
+                }
                 else {
                         __cfaabi_dbg_print_safe("Kernel :  blocking \n");
+                        __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
                         // Some one else has the monitor, wait in line for it
 …
                         BlockInternal( &this->lock );
                         __cfaabi_dbg_print_safe("Kernel : %10p Entered  mon %p\n", thrd, this);
+                        __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
                         // BlockInternal will unlock spinlock, no need to unlock ourselves
 …
+                }
                 __cfaabi_dbg_print_safe("Kernel : %10p Entered  mon %p\n", thrd, this);
+                __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
                 // Release the lock and leave
 …
                 thread_desc * thrd = this_thread;
                 __cfaabi_dbg_print_safe("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
+                __cfaabi_dbg_print_safe( "Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
                 if( !this->owner ) {
                         __cfaabi_dbg_print_safe("Kernel : Destroying free mon %p\n", this);
+                        __cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this);
                         // No one has the monitor, just take it
 …
                         // We already have the monitor... but where about to destroy it so the nesting will fail
                         // Abort!
                         abortf("Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.");
+                        abort( "Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex." );
+                }
 …
                 __monitor_group_t group = { &this, 1, func };
                 if( is_accepted( this, group) ) {
                         __cfaabi_dbg_print_safe("Kernel :  mon accepts dtor, block and signal it \n");
+                        __cfaabi_dbg_print_safe( "Kernel :  mon accepts dtor, block and signal it \n" );
                         // Wake the thread that is waiting for this
 …
+                }
                 else {
                         __cfaabi_dbg_print_safe("Kernel :  blocking \n");
+                        __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
                         wait_ctx( this_thread, 0 )
 …
+                }
                 __cfaabi_dbg_print_safe("Kernel : Destroying %p\n", this);
+                __cfaabi_dbg_print_safe( "Kernel : Destroying %p\n", this);
+        }
 …
                 lock( this->lock __cfaabi_dbg_ctx2 );
                 __cfaabi_dbg_print_safe("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
+                __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
                 verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", this_thread, this->owner, this->recursion, this );
 …
                 // it means we don't need to do anything
                 if( this->recursion != 0) {
                         __cfaabi_dbg_print_safe("Kernel :  recursion still %d\n", this->recursion);
+                        __cfaabi_dbg_print_safe( "Kernel :  recursion still %d\n", this->recursion);
                         unlock( this->lock );
                         return;
 …
                 __cfaabi_dbg_debug_do(
                         if( this_thread != this->owner ) {
                                 abortf("Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner);
+                                abort( "Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner);
+                        }
                         if( this->recursion != 1 ) {
                                 abortf("Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
+                                abort( "Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
+                        }
+                )
 …
                 // If we haven't left the last level of recursion
                 // it must mean there is an error
                 if( this->recursion != 0) { abortf("Thread internal monitor has unbalanced recursion"); }
+                if( this->recursion != 0) { abort( "Thread internal monitor has unbalanced recursion" ); }
                 // Fetch the next thread, can be null
 …
         (this_thread->monitors){m, count, func};
         // __cfaabi_dbg_print_safe("MGUARD : enter %d\n", count);
+        // __cfaabi_dbg_print_safe( "MGUARD : enter %d\n", count);
         // Enter the monitors in order
 …
         enter( group );
         // __cfaabi_dbg_print_safe("MGUARD : entered\n");
+        // __cfaabi_dbg_print_safe( "MGUARD : entered\n" );
+}
 …
 // Dtor for monitor guard
 void ^?{}( monitor_guard_t & this ) {
         // __cfaabi_dbg_print_safe("MGUARD : leaving %d\n", this.count);
+        // __cfaabi_dbg_print_safe( "MGUARD : leaving %d\n", this.count);
         // Leave the monitors in order
         leave( this.m, this.count );
         // __cfaabi_dbg_print_safe("MGUARD : left\n");
+        // __cfaabi_dbg_print_safe( "MGUARD : left\n" );
         // Restore thread context
 …
                 thread_desc * this_thrd = this_thread;
                 if ( this.monitor_count != this_thrd->monitors.size ) {
                         abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", &this, this.monitor_count, this_thrd->monitors.size );
+                        abort( "Signal on condition %p made with different number of monitor(s), expected %i got %i", &this, this.monitor_count, this_thrd->monitors.size );
+                }
                 for(int i = 0; i < this.monitor_count; i++) {
                         if ( this.monitors[i] != this_thrd->monitors[i] ) {
                                 abortf( "Signal on condition %p made with different monitor, expected %p got %i", &this, this.monitors[i], this_thrd->monitors[i] );
+                                abort( "Signal on condition %p made with different monitor, expected %p got %i", &this, this.monitors[i], this_thrd->monitors[i] );
+                        }
+                }
 …
         if(actual_count == 0) return;
         __cfaabi_dbg_print_buffer_local( "Kernel : waitfor internal proceeding\n");
+        __cfaabi_dbg_print_buffer_local( "Kernel : waitfor internal proceeding\n" );
         // Create storage for monitor context
 …
                         __acceptable_t& accepted = mask[index];
                         if( accepted.is_dtor ) {
                                 __cfaabi_dbg_print_buffer_local( "Kernel : dtor already there\n");
+                                __cfaabi_dbg_print_buffer_local( "Kernel : dtor already there\n" );
                                 verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
 …
+                        }
                         else {
                                 __cfaabi_dbg_print_buffer_local( "Kernel : thread present, baton-passing\n");
+                                __cfaabi_dbg_print_buffer_local( "Kernel : thread present, baton-passing\n" );
                                 // Create the node specific to this wait operation
 …
+                                        }
                                 #endif
                                 __cfaabi_dbg_print_buffer_local( "\n");
+                                __cfaabi_dbg_print_buffer_local( "\n" );
                                 // Set the owners to be the next thread
 …
                                 monitor_restore;
                                 __cfaabi_dbg_print_buffer_local( "Kernel : thread present, returned\n");
+                                __cfaabi_dbg_print_buffer_local( "Kernel : thread present, returned\n" );
+                        }
 …
         if( duration == 0 ) {
                 __cfaabi_dbg_print_buffer_local( "Kernel : non-blocking, exiting\n");
+                __cfaabi_dbg_print_buffer_local( "Kernel : non-blocking, exiting\n" );
                 unlock_all( locks, count );
 …
         verifyf( duration < 0, "Timeout on waitfor statments not supported yet.");
         __cfaabi_dbg_print_buffer_local( "Kernel : blocking waitfor\n");
+        verifyf( duration < 0, "Timeout on waitfor statments not supported yet." );
+        __cfaabi_dbg_print_buffer_local( "Kernel : blocking waitfor\n" );
         // Create the node specific to this wait operation
 …
         monitor_restore;
         __cfaabi_dbg_print_buffer_local( "Kernel : exiting\n");
+        __cfaabi_dbg_print_buffer_local( "Kernel : exiting\n" );
         __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
 …
 static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
         // __cfaabi_dbg_print_safe("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
+        // __cfaabi_dbg_print_safe( "Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
         //Pass the monitor appropriately
 …
 static inline thread_desc * next_thread( monitor_desc * this ) {
         //Check the signaller stack
         __cfaabi_dbg_print_safe("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
+        __cfaabi_dbg_print_safe( "Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
         __condition_criterion_t * urgent = pop( this->signal_stack );
         if( urgent ) {
 …
         thread_desc * thrd = this_thread;
         if( !this.monitors ) {
                 // __cfaabi_dbg_print_safe("Branding\n");
+                // __cfaabi_dbg_print_safe( "Branding\n" );
                 assertf( thrd->monitors.data != NULL, "No current monitor to brand condition %p", thrd->monitors.data );
                 this.monitor_count = thrd->monitors.size;

src/libcfa/concurrency/preemption.c

-                      r381fdee
+                      rbede27b
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Feb  9 14:42:34 2018
 // Update Count     : 25
+// Last Modified On : Fri Feb  9 16:38:13 2018
+// Update Count     : 14
 //
 …
+}
+enum {
+        PREEMPT_NORMAL    = 0,
+        PREEMPT_TERMINATE = 1,
+};
 //=============================================================================================
 // Kernel Preemption logic
 …
         if ( pthread_sigmask( SIG_UNBLOCK, &mask, NULL ) == -1 ) {
             abortf( "internal error, pthread_sigmask" );
+            abort( "internal error, pthread_sigmask" );
+        }
+}
 …
         if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
             abortf( "internal error, pthread_sigmask" );
+            abort( "internal error, pthread_sigmask" );
+        }
+}
 …
 // kill wrapper : signal a processor
 static void preempt( processor * this ) {
+        pthread_kill( this->kernel_thread, SIGUSR1 );
+        sigval_t value = { PREEMPT_NORMAL };
+        pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
+}
+// kill wrapper : signal a processor
+void terminate(processor * this) {
+        this->do_terminate = true;
+        sigval_t value = { PREEMPT_TERMINATE };
+        pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
+}
 …
 // Called from kernel_startup
 void kernel_start_preemption() {
         __cfaabi_dbg_print_safe("Kernel : Starting preemption\n");
+        __cfaabi_dbg_print_safe( "Kernel : Starting preemption\n" );
         // Start with preemption disabled until ready
 …
 // Called from kernel_shutdown
 void kernel_stop_preemption() {
         __cfaabi_dbg_print_safe("Kernel : Preemption stopping\n");
+        __cfaabi_dbg_print_safe( "Kernel : Preemption stopping\n" );
         // Block all signals since we are already shutting down
 …
         // Preemption is now fully stopped
         __cfaabi_dbg_print_safe("Kernel : Preemption stopped\n");
+        __cfaabi_dbg_print_safe( "Kernel : Preemption stopped\n" );
+}
 …
         __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.CFA_REG_IP); )
+        // SKULLDUGGERY: if a thread creates a processor and the immediately deletes it,
+        // the interrupt that is supposed to force the kernel thread to preempt might arrive
+        // before the kernel thread has even started running. When that happens an iterrupt
+        // we a null 'this_processor' will be caught, just ignore it.
+        if(!this_processor) return;
+        choose(sfp->si_value.sival_int) {
+                case PREEMPT_NORMAL   : ;// Normal case, nothing to do here
+                case PREEMPT_TERMINATE: verify(this_processor->do_terminate);
+                default:
+                        abort( "internal error, signal value is %d", sfp->si_value.sival_int );
+        }
         // Check if it is safe to preempt here
         if( !preemption_ready() ) { return; }
         __cfaabi_dbg_print_buffer_decl(" KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
+        __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
 …
         if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
             abortf( "internal error, pthread_sigmask" );
+            abort( "internal error, pthread_sigmask" );
+        }
 …
                                         continue;
                         case EINVAL :
                                         abortf("Timeout was invalid.");
+                                        abort( "Timeout was invalid." );
                                 default:
                                         abortf("Unhandled error %d", err);
+                                        abort( "Unhandled error %d", err);
+                        }
+                }
 …
                 assertf(sig == SIGALRM, "Kernel Internal Error, sigwait: Unexpected signal %d (%d : %d)\n", sig, info.si_code, info.si_value.sival_int);
                 // __cfaabi_dbg_print_safe("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
+                // __cfaabi_dbg_print_safe( "Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
                 // Switch on the code (a.k.a. the sender) to
                 switch( info.si_code )
 …
                 case SI_TIMER:
                 case SI_KERNEL:
                         // __cfaabi_dbg_print_safe("Kernel : Preemption thread tick\n");
+                        // __cfaabi_dbg_print_safe( "Kernel : Preemption thread tick\n" );
                         lock( event_kernel->lock __cfaabi_dbg_ctx2 );
                         tick_preemption();
 …
 EXIT:
         __cfaabi_dbg_print_safe("Kernel : Preemption thread stopping\n");
+        __cfaabi_dbg_print_safe( "Kernel : Preemption thread stopping\n" );
         return NULL;
+}

src/libcfa/interpose.c

-                      r381fdee
+                      rbede27b
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Feb  6 17:57:56 2018
 // Update Count     : 49
+// Last Modified On : Thu Feb  8 16:18:09 2018
+// Update Count     : 75
 //
 …
 #include "startup.h"
+//=============================================================================================
+// Interposing helpers
+//=============================================================================================
 typedef void (*generic_fptr_t)(void);
 generic_fptr_t interpose_symbol( const char* symbol, const char *version ) {
 …
                         error = dlerror();
                         if ( error ) {
                                 abortf( "interpose_symbol : failed to open libc, %s\n", error );
+                                abort( "interpose_symbol : failed to open libc, %s\n", error );
+                        }
                 #endif
 …
         error = dlerror();
         if ( error ) abortf( "interpose_symbol : internal error, %s\n", error );
+        if ( error ) abort( "interpose_symbol : internal error, %s\n", error );
         return originalFunc.fptr;
+}
-__typeof__( exit ) libc_exit __attribute__(( noreturn ));
-__typeof__( abort ) libc_abort __attribute__(( noreturn ));
 forall(dtype T)
 static inline void assign_ptr( T** symbol_ptr, const char * symbol_name, const char * version) {
+static inline void ptr_from_symbol( T** symbol_ptr, const char * symbol_name, const char * version) {
         union {
                 generic_fptr_t gp;
 …
+}
+#define INIT_REALRTN( x, ver ) assign_ptr( (void**)&libc_##x, #x, ver)
+#define INTERPOSE_LIBC( x, ver ) ptr_from_symbol( (void**)&__cabi_libc.x, #x, ver)
+//=============================================================================================
+// Terminating Signals logic
+//=============================================================================================
 void sigHandler_segv ( __CFA_SIGPARMS__ );
 …
 void sigHandler_abort( __CFA_SIGPARMS__ );
+struct {
+        void (* exit)( int ) __attribute__ (( __noreturn__ ));
+        void (* abort)( void ) __attribute__ (( __noreturn__ ));
+} __cabi_libc;
 extern "C" {
         void __cfaabi_interpose_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_CORE ) ));
 …
                 const char *version = NULL;
                 INIT_REALRTN( abort, version );
                 INIT_REALRTN( exit, version );
+                INTERPOSE_LIBC( abort, version );
+                INTERPOSE_LIBC( exit , version );
                 __cfaabi_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO ); // Failure handler
 …
 //=============================================================================================
+// Forward declare abort after the __typeof__ call to avoid ambiguities
+void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
+void abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
 extern "C" {
         void abort( void ) __attribute__ ((__nothrow__, __leaf__, __noreturn__)) {
                 abortf( NULL );
+        }
         void exit( int __status ) __attribute__ ((__nothrow__, __leaf__, __noreturn__)) {
                 libc_exit(__status);
+        }
+}
+void abort( const char fmt[], ... ) __attribute__ ((__nothrow__, __leaf__, __noreturn__)) {
+        va_list argp;
         va_start( argp, fmt );
         abortf( fmt, argp );
         va_end( argp );
+}
 void * kernel_abort    ( void ) __attribute__ ((__nothrow__, __leaf__, __weak__)) { return NULL; }
 void   kernel_abort_msg( void * data, char * buffer, int size ) __attribute__ ((__nothrow__, __leaf__, __weak__)) {}
 int kernel_abort_lastframe( void ) __attribute__ ((__nothrow__, __leaf__, __weak__)) { return 4; }
+        void abort( void ) __attribute__ (( __nothrow__, __leaf__, __noreturn__ )) {
+                abort( NULL );
+        }
+        void __cabi_abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )) {
+                va_list argp;
+                va_start( argp, fmt );
+                abort( fmt, argp );
+                va_end( argp );
+        }
+        void exit( int status ) __attribute__ (( __nothrow__, __leaf__, __noreturn__ )) {
+                __cabi_libc.exit( status );
+        }
+}
+void * kernel_abort    ( void ) __attribute__ (( __nothrow__, __leaf__, __weak__ )) { return NULL; }
+void   kernel_abort_msg( void * data, char * buffer, int size ) __attribute__ (( __nothrow__, __leaf__, __weak__ )) {}
+int kernel_abort_lastframe( void ) __attribute__ (( __nothrow__, __leaf__, __weak__ )) { return 4; }
 enum { abort_text_size = 1024 };
 …
 static int abort_lastframe;
+extern "C" {
+        void abortf( const char fmt[], ... ) __attribute__ ((__nothrow__, __leaf__, __noreturn__)) {
+                void * kernel_data = kernel_abort();                    // must be done here to lock down kernel
+                int len;
+                abort_lastframe = kernel_abort_lastframe();
+                len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld) ", (long int)getpid() ); // use UNIX pid (versus getPid)
+void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ )) {
+    va_list args;
+    va_start( args, fmt );
+    vfprintf( stderr, fmt, args );
+    va_end( args );
+        __cabi_libc.exit( status );
+}
+void abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )) {
+        void * kernel_data = kernel_abort();                    // must be done here to lock down kernel
+        int len;
+        abort_lastframe = kernel_abort_lastframe();
+        len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld) ", (long int)getpid() ); // use UNIX pid (versus getPid)
+        __cfaabi_dbg_bits_write( abort_text, len );
+        if ( fmt ) {
+                va_list args;
+                va_start( args, fmt );
+                len = vsnprintf( abort_text, abort_text_size, fmt, args );
+                va_end( args );
                 __cfaabi_dbg_bits_write( abort_text, len );
+                if ( fmt ) {
+                        va_list args;
+                        va_start( args, fmt );
+                        len = vsnprintf( abort_text, abort_text_size, fmt, args );
+                        va_end( args );
+                        __cfaabi_dbg_bits_write( abort_text, len );
+                        if ( fmt[strlen( fmt ) - 1] != '\n' ) {         // add optional newline if missing at the end of the format text
+                                __cfaabi_dbg_bits_write( "\n", 1 );
+                        }
+                }
+                kernel_abort_msg( kernel_data, abort_text, abort_text_size );
+                libc_abort();
+        }
+                if ( fmt[strlen( fmt ) - 1] != '\n' ) {         // add optional newline if missing at the end of the format text
+                        __cfaabi_dbg_bits_write( "\n", 1 );
+                }
+        }
+        kernel_abort_msg( kernel_data, abort_text, abort_text_size );
+        __cabi_libc.abort();
+}
 …
 void sigHandler_segv( __CFA_SIGPARMS__ ) {
         abortf( "Attempt to address location %p\n"
+        abort( "Addressing invalid memory at location %p\n"
                         "Possible cause is reading outside the address space or writing to a protected area within the address space with an invalid pointer or subscript.\n",
                         sfp->si_addr );
 …
 void sigHandler_ill( __CFA_SIGPARMS__ ) {
         abortf( "Attempt to execute code at location %p.\n"
+        abort( "Executing illegal instruction at location %p.\n"
                         "Possible cause is stack corruption.\n",
                         sfp->si_addr );
 …
         const char * msg;
+        switch ( sfp->si_code ) {
+          case FPE_INTDIV:
+          case FPE_FLTDIV: msg = "divide by zero"; break;
+          case FPE_FLTOVF: msg = "overflow"; break;
+          case FPE_FLTUND: msg = "underflow"; break;
+          case FPE_FLTRES: msg = "inexact result"; break;
+          case FPE_FLTINV: msg = "invalid operation"; break;
+        choose( sfp->si_code ) {
+          case FPE_INTDIV, FPE_FLTDIV: msg = "divide by zero";
+          case FPE_FLTOVF: msg = "overflow";
+          case FPE_FLTUND: msg = "underflow";
+          case FPE_FLTRES: msg = "inexact result";
+          case FPE_FLTINV: msg = "invalid operation";
           default: msg = "unknown";
+        } // switch
+        abortf( "Floating point error.\n"
+                        "Cause is %s.\n", msg );
+        } // choose
+        abort( "Computation error %s at location %p.\n", msg, sfp->si_addr );
+}

src/main.cc

-                      r381fdee
+                      rbede27b
         exprp = false,
         expraltp = false,
+        genericsp = false,
         libcfap = false,
         nopreludep = false,
 …
                 OPTPRINT("instantiateGenerics")
                 GenPoly::instantiateGeneric( translationUnit );
+                if ( genericsp ) {
+                        dump( translationUnit );
+                        return 0;
+                }
                 OPTPRINT( "convertLvalue" )
                 GenPoly::convertLvalue( translationUnit );
                 if ( bboxp ) {
                         dump( translationUnit );
 …
                 CodeTools::fillLocations( translationUnit );
+                OPTPRINT( "codegen" )
                 CodeGen::generate( translationUnit, *output, ! noprotop, prettycodegenp, true, linemarks );
                 CodeGen::FixMain::fix( *output, treep ? "../prelude/bootloader.c" : CFA_LIBDIR "/bootloader.c" );
+                OPTPRINT( "end" )
                 if ( output != &cout ) {
 …
         int c;
         while ( (c = getopt_long( argc, argv, "abBcCdefglLmnNpqrstTvyzZD:F:", long_opts, &long_index )) != -1 ) {
+        while ( (c = getopt_long( argc, argv, "abBcCdefgGlLmnNpqrstTvyzZD:F:", long_opts, &long_index )) != -1 ) {
                 switch ( c ) {
                   case Ast:
 …
                   case 'g':                                                                             // bison debugging info (grammar rules)
                         yydebug = true;
+                        break;
+                  case 'G':                   // dump AST after instantiate generics
+                        genericsp = true;
                         break;
                   case LibCFA:

src/prelude/builtins.c

-                      r381fdee
+                      rbede27b
 // Author           : Peter A. Buhr
 // Created On       : Fri Jul 21 16:21:03 2017
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Jul 25 15:33:00 2017
 // Update Count     : 14
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Feb  8 12:47:59 2018
+// Update Count     : 19
 //
 …
 #include "../libcfa/virtual.h"
 #include "../libcfa/exception.h"
+void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
+void abort ( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
 // exponentiation operator implementation

Context Navigation

Legend:

doc/papers/general/Makefile

doc/papers/general/Paper.tex

src/Common/PassVisitor.impl.h

src/GenPoly/Lvalue.cc

src/libcfa/bits/debug.c

src/libcfa/bits/debug.h

src/libcfa/bits/defs.h

src/libcfa/concurrency/coroutine.c

src/libcfa/concurrency/invoke.c

src/libcfa/concurrency/kernel.c

src/libcfa/concurrency/kernel_private.h

src/libcfa/concurrency/monitor.c

src/libcfa/concurrency/preemption.c

src/libcfa/interpose.c

src/main.cc

src/prelude/builtins.c

Download in other formats: