Changeset 5407cdc for doc

doc/LaTeXmacros/lstlang.sty

-              rfeacef9
+              r5407cdc
 %% Created On       : Sat May 13 16:34:42 2017
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Wed Sep 23 22:40:04 2020
 %% Update Count     : 24
+%% Last Modified On : Wed Feb 17 09:21:15 2021
+%% Update Count     : 27
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
         morekeywords={
                 _Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, __attribute, __attribute__,
                 auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__, __const, __const__,
                 coroutine, disable, dtype, enable, exception, __extension__, fallthrough, fallthru, finally,
+                auto, basetypeof, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__, __const, __const__,
+                coroutine, disable, dtype, enable, exception, __extension__, fallthrough, fallthru, finally, fixup,
                 __float80, float80, __float128, float128, forall, ftype, generator, _Generic, _Imaginary, __imag, __imag__,
                 inline, __inline, __inline__, __int128, int128, __label__, monitor, mutex, _Noreturn, one_t, or,
                 otype, restrict, __restrict, __restrict__, __signed, __signed__, _Static_assert, suspend, thread,
                 _Thread_local, throw, throwResume, timeout, trait, try, ttype, typeof, __typeof, __typeof__,
+                otype, restrict, __restrict, __restrict__, recover, report, __signed, __signed__, _Static_assert, suspend,
+                thread, _Thread_local, throw, throwResume, timeout, trait, try, ttype, typeof, __typeof, __typeof__,
                 virtual, __volatile, __volatile__, waitfor, when, with, zero_t,
     },

doc/bibliography/pl.bib

-              rfeacef9
+              r5407cdc
+}
 @article{Delisle20,
+@article{Delisle21,
     keywords    = {concurrency, Cforall},
     contributer = {pabuhr@plg},
     author      = {Thierry Delisle and Peter A. Buhr},
     title       = {Advanced Control-flow and Concurrency in \textsf{C}$\mathbf{\forall}$},
-    year        = 2020,
     journal     = spe,
+    pages       = {1-38},
+    note        = {\href{https://doi-org.proxy.lib.uwaterloo.ca/10.1002/spe.2925}{https://\-doi-org.proxy.lib.uwaterloo.ca/\-10.1002/\-spe.2925}},
+    note        = {},
+    month       = may,
+    year        = 2021,
+    volume      = 51,
+    number      = 5,
+    pages       = {1005-1042},
+    note        = {\href{https://onlinelibrary.wiley.com/doi/10.1002/spe.2925}{https://\-onlinelibrary.wiley.com/\-doi/\-10.1002/\-spe.2925}},
+}
 …
     month       = jan,
     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     note        = {\textsf{http://uwspace.uwaterloo.ca/\-bitstream/\-10012/\-3501/\-1/\-Thesis.pdf}},
+    note        = {\href{http://uwspace.uwaterloo.ca/bitstream/10012/3501/1/Thesis.pdf}{http://\-uwspace.uwaterloo.ca/\-bitstream/\-10012/\-3501/\-1/\-Thesis.pdf}},
+}

doc/theses/andrew_beach_MMath/Makefile

-              rfeacef9
+              r5407cdc
 BUILD=out
 TEXSRC=$(wildcard *.tex)
+FIGSRC=$(wildcard *.fig)
 BIBSRC=$(wildcard *.bib)
 STYSRC=$(wildcard *.sty)
 …
 BASE= ${DOC:%.pdf=%}
+RAWSRC=${TEXSRC} ${BIBSRC} ${STYSRC} ${CLSSRC}
+FIGTEX=${FIGSRC:%.fig=${BUILD}/%.tex}
 ### Special Rules:
 …
 ### Commands:
 LATEX=TEXINPUTS=${TEXLIB} pdflatex -halt-on-error -output-directory=${BUILD}
+LATEX=TEXINPUTS=${TEXLIB} latex -halt-on-error -output-directory=${BUILD}
 BIBTEX=BIBINPUTS=${BIBLIB} bibtex
 GLOSSARY=INDEXSTYLE=${BUILD} makeglossaries-lite
 …
 all: ${DOC}
+${BUILD}/${DOC}: ${TEXSRC} ${BIBSRC} ${STYSRC} ${CLSSRC} Makefile | ${BUILD}
+# The main rule, it does all the tex/latex processing.
+${BUILD}/${BASE}.dvi: ${RAWSRC} ${FIGTEX} Makefile | ${BUILD}
         ${LATEX} ${BASE}
         ${BIBTEX} ${BUILD}/${BASE}
 …
         ${LATEX} ${BASE}
+${DOC}: ${BUILD}/${DOC}
+        cp $< $@
+# Convert xfig output to tex. (Generates \special declarations.)
+${FIGTEX}: ${BUILD}/%.tex: %.fig | ${BUILD}
+        fig2dev -L eepic $< > $@
+# Step through dvi & postscript to handle xfig specials.
+%.pdf : ${BUILD}/%.dvi
+        dvipdf $^ $@
 ${BUILD}:

doc/theses/andrew_beach_MMath/existing.tex

-              rfeacef9
+              r5407cdc
 \section{Overloading and \lstinline{extern}}
 \CFA has extensive overloading, allowing multiple definitions of the same name
 to be defined.~\cite{Moss18}
+to be defined~\cite{Moss18}.
 \begin{cfa}
 char i; int i; double i;                        $\C[3.75in]{// variable overload}$
 …
 pointers using the ampersand (@&@) instead of the pointer asterisk (@*@). \CFA
 references may also be mutable or non-mutable. If mutable, a reference variable
 may be assigned to using the address-of operator (@&@), which converts the
+may be assigned using the address-of operator (@&@), which converts the
 reference to a pointer.
 \begin{cfa}
 …
 \section{Constructors and Destructors}
 Both constructors and destructors are operators, which means they are just
+Both constructors and destructors are operators, which means they are
 functions with special operator names rather than type names in \Cpp. The
 special operator names may be used to call the functions explicitly (not
 …
 In general, operator names in \CFA are constructed by bracketing an operator
 token with @?@, which indicates where the arguments. For example, infixed
+token with @?@, which indicates the position of the arguments. For example, infixed
 multiplication is @?*?@ while prefix dereference is @*?@. This syntax make it
 easy to tell the difference between prefix operations (such as @++?@) and
 …
 definition, \CFA creates a default and copy constructor, destructor and
 assignment (like \Cpp). It is possible to define constructors/destructors for
 basic and existing types.
+basic and existing types (unlike \Cpp).
 \section{Polymorphism}
 …
         do_once(value);
+}
 void do_once(int i) { ... }  // provide assertion
 int i;
+void do_once(@int@ i) { ... }  // provide assertion
+@int@ i;
 do_twice(i); // implicitly pass assertion do_once to do_twice
 \end{cfa}
 …
 declarations instead of parameters, returns, and local variable declarations.
 \begin{cfa}
 forall(dtype T)
+forall(dtype @T@)
 struct node {
+        node(T) * next;  // generic linked node
+        T * data;
+}
+        node(@T@) * next;  // generic linked node
+        @T@ * data;
+}
+node(@int@) inode;
 \end{cfa}
 The generic type @node(T)@ is an example of a polymorphic-type usage.  Like \Cpp
 templates usage, a polymorphic-type usage must specify a type parameter.
+template usage, a polymorphic-type usage must specify a type parameter.
 There are many other polymorphism features in \CFA but these are the ones used
 by the exception system.
 \section{Concurrency}
 \CFA has a number of concurrency features: @thread@, @monitor@, @mutex@
 parameters, @coroutine@ and @generator@. The two features that interact with
 the exception system are @thread@ and @coroutine@; they and their supporting
+\section{Control Flow}
+\CFA has a number of advanced control-flow features: @generator@, @coroutine@, @monitor@, @mutex@ parameters, and @thread@.
+The two features that interact with
+the exception system are @coroutine@ and @thread@; they and their supporting
 constructs are described here.
 …
 CountUp countup;
 \end{cfa}
 Each coroutine has @main@ function, which takes a reference to a coroutine
+Each coroutine has a @main@ function, which takes a reference to a coroutine
 object and returns @void@.
 \begin{cfa}[numbers=left]
 …
 In this function, or functions called by this function (helper functions), the
 @suspend@ statement is used to return execution to the coroutine's caller
 without terminating the coroutine.
+without terminating the coroutine's function.
 A coroutine is resumed by calling the @resume@ function, \eg @resume(countup)@.
 …
 @resume(countup).next@.
 \subsection{Monitors and Mutex}
+\subsection{Monitor and Mutex Parameter}
 Concurrency does not guarantee ordering; without ordering results are
 non-deterministic. To claw back ordering, \CFA uses monitors and @mutex@
 …
 and only one runs at a time.
 \subsection{Threads}
+\subsection{Thread}
 Functions, generators, and coroutines are sequential so there is only a single
 (but potentially sophisticated) execution path in a program. Threads introduce
 …
 monitors and mutex parameters. For threads to work safely with other threads,
 also requires mutual exclusion in the form of a communication rendezvous, which
 also supports internal synchronization as for mutex objects. For exceptions
 only the basic two basic operations are important: thread fork and join.
+also supports internal synchronization as for mutex objects. For exceptions,
+only two basic thread operations are important: fork and join.
 Threads are created like coroutines with an associated @main@ function:

doc/theses/andrew_beach_MMath/features.tex

-              rfeacef9
+              r5407cdc
 This chapter covers the design and user interface of the \CFA
+exception-handling mechanism.
+exception-handling mechanism (EHM). % or exception system.
+We will begin with an overview of EHMs in general. It is not a strict
+definition of all EHMs nor an exaustive list of all possible features.
+However it does cover the most common structure and features found in them.
+% We should cover what is an exception handling mechanism and what is an
+% exception before this. Probably in the introduction. Some of this could
+% move there.
+\paragraph{Raise / Handle}
+An exception operation has two main parts: raise and handle.
+These terms are sometimes also known as throw and catch but this work uses
+throw/catch as a particular kind of raise/handle.
+These are the two parts that the user will write themselves and may
+be the only two pieces of the EHM that have any syntax in the language.
+\subparagraph{Raise}
+The raise is the starting point for exception handling. It marks the beginning
+of exception handling by \newterm{raising} an excepion, which passes it to
+the EHM.
+Some well known examples include the @throw@ statements of \Cpp and Java and
+the \codePy{raise} statement from Python. In real systems a raise may preform
+some other work (such as memory management) but for the purposes of this
+overview that can be ignored.
+\subparagraph{Handle}
+The purpose of most exception operations is to run some user code to handle
+that exception. This code is given, with some other information, in a handler.
+A handler has three common features: the previously mentioned user code, a
+region of code they cover and an exception label/condition that matches
+certain exceptions.
+Only raises inside the covered region and raising exceptions that match the
+label can be handled by a given handler.
+Different EHMs will have different rules to pick a handler
+if multipe handlers could be used such as ``best match" or ``first found".
+The @try@ statements of \Cpp, Java and Python are common examples. All three
+also show another common feature of handlers, they are grouped by the covered
+region.
+\paragraph{Propagation}
+After an exception is raised comes what is usually the biggest step for the
+EHM: finding and setting up the handler. The propogation from raise to
+handler can be broken up into three different tasks: searching for a handler,
+matching against the handler and installing the handler.
+\subparagraph{Searching}
+The EHM begins by searching for handlers that might be used to handle
+the exception. Searching is usually independent of the exception that was
+thrown as it looks for handlers that have the raise site in their covered
+region.
+This includes handlers in the current function, as well as any in callers
+on the stack that have the function call in their covered region.
+\subparagraph{Matching}
+Each handler found has to be matched with the raised exception. The exception
+label defines a condition that be use used with exception and decides if
+there is a match or not.
+In languages where the first match is used this step is intertwined with
+searching, a match check is preformed immediately after the search finds
+a possible handler.
+\subparagraph{Installing}
+After a handler is chosen it must be made ready to run.
+The implementation can vary widely to fit with the rest of the
+design of the EHM. The installation step might be trivial or it could be
+the most expensive step in handling an exception. The latter tends to be the
+case when stack unwinding is involved.
+If a matching handler is not guarantied to be found the EHM will need a
+different course of action here in the cases where no handler matches.
+This is only required with unchecked exceptions as checked exceptions
+(such as in Java) can make than guaranty.
+This different action can also be installing a handler but it is usually an
+implicat and much more general one.
+\subparagraph{Hierarchy}
+A common way to organize exceptions is in a hierarchical structure.
+This is especially true in object-orientated languages where the
+exception hierarchy is a natural extension of the object hierarchy.
+Consider the following hierarchy of exceptions:
+\begin{center}
+\input{exception-hierarchy}
+\end{center}
+A handler labelled with any given exception can handle exceptions of that
+type or any child type of that exception. The root of the exception hierarchy
+(here \codeC{exception}) acts as a catch-all, leaf types catch single types
+and the exceptions in the middle can be used to catch different groups of
+related exceptions.
+This system has some notable advantages, such as multiple levels of grouping,
+the ability for libraries to add new exception types and the isolation
+between different sub-hierarchies.
+This design is used in \CFA even though it is not a object-orientated
+language using different tools to create the hierarchy.
+% Could I cite the rational for the Python IO exception rework?
+\paragraph{Completion}
+After the handler has finished the entire exception operation has to complete
+and continue executing somewhere else. This step is usually simple,
+both logically and in its implementation, as the installation of the handler
+is usually set up to do most of the work.
+The EHM can return control to many different places,
+the most common are after the handler definition and after the raise.
+\paragraph{Communication}
+For effective exception handling, additional information is usually passed
+from the raise to the handler.
+So far only communication of the exceptions' identity has been covered.
+A common method is putting fields into the exception instance and giving the
+handler access to them.
 \section{Virtuals}
+Virtual types and casts are not part of the exception system nor are they
+required for an exception system. But an object-oriented style hierarchy is a
+great way of organizing exceptions so a minimal virtual system has been added
+to \CFA.
+The pattern of a simple hierarchy was borrowed from object-oriented
+programming was chosen for several reasons.
+The first is that it allows new exceptions to be added in user code
+and in libraries independently of each other. Another is it allows for
+different levels of exception grouping (all exceptions, all IO exceptions or
+a particular IO exception). Also it also provides a simple way of passing
+data back and forth across the throw.
+Virtual types and casts are not required for a basic exception-system but are
+useful for advanced exception features. However, \CFA is not object-oriented so
+there is no obvious concept of virtuals. Hence, to create advanced exception
+features for this work, I needed to design and implement a virtual-like
+system for \CFA.
+% NOTE: Maybe we should but less of the rational here.
+Object-oriented languages often organized exceptions into a simple hierarchy,
+\eg Java.
+\begin{center}
+\setlength{\unitlength}{4000sp}%
+\begin{picture}(1605,612)(2011,-1951)
+\put(2100,-1411){\vector(1, 0){225}}
+\put(3450,-1411){\vector(1, 0){225}}
+\put(3550,-1411){\line(0,-1){225}}
+\put(3550,-1636){\vector(1, 0){150}}
+\put(3550,-1636){\line(0,-1){225}}
+\put(3550,-1861){\vector(1, 0){150}}
+\put(2025,-1490){\makebox(0,0)[rb]{\LstBasicStyle{exception}}}
+\put(2400,-1460){\makebox(0,0)[lb]{\LstBasicStyle{arithmetic}}}
+\put(3750,-1460){\makebox(0,0)[lb]{\LstBasicStyle{underflow}}}
+\put(3750,-1690){\makebox(0,0)[lb]{\LstBasicStyle{overflow}}}
+\put(3750,-1920){\makebox(0,0)[lb]{\LstBasicStyle{zerodivide}}}
+\end{picture}%
+\end{center}
+The hierarchy provides the ability to handle an exception at different degrees
+of specificity (left to right). Hence, it is possible to catch a more general
+exception-type in higher-level code where the implementation details are
+unknown, which reduces tight coupling to the lower-level implementation.
+Otherwise, low-level code changes require higher-level code changes, \eg,
+changing from raising @underflow@ to @overflow@ at the low level means changing
+the matching catch at the high level versus catching the general @arithmetic@
+exception. In detail, each virtual type may have a parent and can have any
+number of children. A type's descendants are its children and its children's
+descendants. A type may not be its own descendant.
+The exception hierarchy allows a handler (@catch@ clause) to match multiple
+exceptions, \eg a base-type handler catches both base and derived
+exception-types.
+\begin{cfa}
+try {
+        ...
+} catch(arithmetic &) {
+        ... // handle arithmetic, underflow, overflow, zerodivide
+}
+\end{cfa}
+Most exception mechanisms perform a linear search of the handlers and select
+the first matching handler, so the order of handers is now important because
+matching is many to one.
+Each virtual type needs an associated virtual table. A virtual table is a
+structure with fields for all the virtual members of a type. A virtual type has
+all the virtual members of its parent and can add more. It may also update the
+values of the virtual members and often does.
+Virtual types and casts are not part of \CFA's EHM nor are they required for
+any EHM. But \CFA uses a hierarchial system of exceptions and this feature
+is leveraged to create that.
+% Maybe talk about why the virtual system is so minimal.
+% Created for but not a part of the exception system.
+The virtual system supports multiple ``trees" of types. Each tree is
+a simple hierarchy with a single root type. Each type in a tree has exactly
+one parent -- except for the root type which has zero parents -- and any
+number of children.
+Any type that belongs to any of these trees is called a virtual type.
+% A type's ancestors are its parent and its parent's ancestors.
+% The root type has no ancestors.
+% A type's decendents are its children and its children's decendents.
+Every virtual type also has a list of virtual members. Children inherit
+their parent's list of virtual members but may add new members to it.
+It is important to note that these are virtual members, not virtual methods
+of object-orientated programming, and can be of any type.
+However, since \CFA has function pointers and they are allowed, virtual
+members can be used to mimic virtual methods.
+Each virtual type has a unique id.
+This unique id and all the virtual members are combined
+into a virtual table type. Each virtual type has a pointer to a virtual table
+as a hidden field.
+Up until this point the virtual system is similar to ones found in
+object-orientated languages but this where \CFA diverges. Objects encapsulate a
+single set of behaviours in each type, universally across the entire program,
+and indeed all programs that use that type definition. In this sense the
+types are ``closed" and cannot be altered.
+In \CFA types do not encapsulate any behaviour. Traits are local and
+types can begin to statify a trait, stop satifying a trait or satify the same
+trait in a different way at any lexical location in the program.
+In this sense they are ``open" as they can change at any time. This means it
+is implossible to pick a single set of functions that repersent the type's
+implementation across the program.
+\CFA side-steps this issue by not having a single virtual table for each
+type. A user can define virtual tables which are filled in at their
+declaration and given a name. Anywhere that name is visible, even if it was
+defined locally inside a function (although that means it will not have a
+static lifetime), it can be used.
+Specifically, a virtual type is ``bound" to a virtual table which
+sets the virtual members for that object. The virtual members can be accessed
+through the object.
 While much of the virtual infrastructure is created, it is currently only used
 …
 \Cpp syntax for special casts. Both the type of @EXPRESSION@ and @TYPE@ must be
 a pointer to a virtual type.
 The cast dynamically checks if the @EXPRESSION@ type is the same or a subtype
+The cast dynamically checks if the @EXPRESSION@ type is the same or a sub-type
 of @TYPE@, and if true, returns a pointer to the
 @EXPRESSION@ object, otherwise it returns @0p@ (null pointer).
 …
 \end{cfa}
 The trait is defined over two types, the exception type and the virtual table
 type. This should be one-to-one, each exception type has only one virtual
+type. This should be one-to-one: each exception type has only one virtual
 table type and vice versa. The only assertion in the trait is
 @get_exception_vtable@, which takes a pointer of the exception type and
 returns a reference to the virtual table type instance.
+% TODO: This section, and all references to get_exception_vtable, are
+% out-of-data. Perhaps wait until the update is finished before rewriting it.
 The function @get_exception_vtable@ is actually a constant function.
 Recardless of the value passed in (including the null pointer) it should
+Regardless of the value passed in (including the null pointer) it should
 return a reference to the virtual table instance for that type.
 The reason it is a function instead of a constant is that it make type
 …
 % similar system I know of (except Agda's I guess) so I took it out.
+There are two more traits for exceptions @is_termination_exception@ and
+@is_resumption_exception@. They are defined as follows:
+There are two more traits for exceptions defined as follows:
 \begin{cfa}
 trait is_termination_exception(
 …
 };
 \end{cfa}
+In other words they make sure that a given type and virtual type is an
+exception and defines one of the two default handlers. These default handlers
+are used in the main exception handling operations \see{Exception Handling}
+and their use will be detailed there.
+However all three of these traits can be trickly to use directly.
+There is a bit of repetition required but
+Both traits ensure a pair of types are an exception type and its virtual table
+and defines one of the two default handlers. The default handlers are used
+as fallbacks and are discussed in detail in \VRef{s:ExceptionHandling}.
+However, all three of these traits can be tricky to use directly.
+While there is a bit of repetition required,
 the largest issue is that the virtual table type is mangled and not in a user
 facing way. So there are three macros that can be used to wrap these traits
 when you need to refer to the names:
+facing way. So these three macros are provided to wrap these traits to
+simplify referring to the names:
 @IS_EXCEPTION@, @IS_TERMINATION_EXCEPTION@ and @IS_RESUMPTION_EXCEPTION@.
 All take one or two arguments. The first argument is the name of the
 exception type. Its unmangled and mangled form are passed to the trait.
+All three take one or two arguments. The first argument is the name of the
+exception type. The macro passes its unmangled and mangled form to the trait.
 The second (optional) argument is a parenthesized list of polymorphic
 arguments. This argument should only with polymorphic exceptions and the
 list will be passed to both types.
 In the current set-up the base name and the polymorphic arguments have to
 match so these macros can be used without losing flexability.
+arguments. This argument is only used with polymorphic exceptions and the
+list is be passed to both types.
+In the current set-up, the two types always have the same polymorphic
+arguments so these macros can be used without losing flexibility.
 For example consider a function that is polymorphic over types that have a
 …
 \section{Exception Handling}
 \CFA provides two kinds of exception handling, termination and resumption.
+These twin operations are the core of the exception handling mechanism and
 are the reason for the features of exceptions.
+\label{s:ExceptionHandling}
+\CFA provides two kinds of exception handling: termination and resumption.
+These twin operations are the core of \CFA's exception handling mechanism.
 This section will cover the general patterns shared by the two operations and
 then go on to cover the details each individual operation.
+Both operations follow the same set of steps to do their operation. They both
+start with the user preforming a throw on an exception.
+Then there is the search for a handler, if one is found than the exception
+is caught and the handler is run. After that control returns to normal
+execution.
+Both operations follow the same set of steps.
+Both start with the user preforming a raise on an exception.
+Then the exception propogates up the stack.
+If a handler is found the exception is caught and the handler is run.
+After that control returns to normal execution.
 If the search fails a default handler is run and then control
+returns to normal execution immediately. That is where the default handlers
+@defaultTermiationHandler@ and @defaultResumptionHandler@ are used.
+returns to normal execution after the raise.
+This general description covers what the two kinds have in common.
+Differences include how propogation is preformed, where exception continues
+after an exception is caught and handled and which default handler is run.
 \subsection{Termination}
 \label{s:Termination}
+Termination handling is more familiar kind and used in most programming
+Termination handling is the familiar kind and used in most programming
 languages with exception handling.
+It is dynamic, non-local goto. If a throw is successful then the stack will
+be unwound and control will (usually) continue in a different function on
+the call stack. They are commonly used when an error has occured and recovery
+is impossible in the current function.
+It is dynamic, non-local goto. If the raised exception is matched and
+handled the stack is unwound and control will (usually) continue the function
+on the call stack that defined the handler.
+Termination is commonly used when an error has occurred and recovery is
+impossible locally.
 % (usually) Control can continue in the current function but then a different
 % control flow construct should be used.
 A termination throw is started with the @throw@ statement:
+A termination raise is started with the @throw@ statement:
 \begin{cfa}
 throw EXPRESSION;
 \end{cfa}
 The expression must return a reference to a termination exception, where the
+termination exception is any type that satifies @is_termination_exception@
+at the call site.
+Through \CFA's trait system the functions in the traits are passed into the
+throw code. A new @defaultTerminationHandler@ can be defined in any scope to
+termination exception is any type that satisfies the trait
+@is_termination_exception@ at the call site.
+Through \CFA's trait system the trait functions are implicity passed into the
+throw code and the EHM.
+A new @defaultTerminationHandler@ can be defined in any scope to
 change the throw's behavior (see below).
+The throw will copy the provided exception into managed memory. It is the
+user's responcibility to ensure the original exception is cleaned up if the
+stack is unwound (allocating it on the stack should be sufficient).
+Then the exception system searches the stack using the copied exception.
+It starts starts from the throw and proceeds to the base of the stack,
+The throw will copy the provided exception into managed memory to ensure
+the exception is not destroyed if the stack is unwound.
+It is the user's responsibility to ensure the original exception is cleaned
+up wheither the stack is unwound or not. Allocating it on the stack is
+usually sufficient.
+Then propogation starts with the search. \CFA uses a ``first match" rule so
+matching is preformed with the copied exception as the search continues.
+It starts from the throwing function and proceeds to the base of the stack,
 from callee to caller.
 At each stack frame, a check is made for resumption handlers defined by the
 …
 try {
         GUARDED_BLOCK
 } catch (EXCEPTION_TYPE$\(_1\)$ * NAME$\(_1\)$) {
+} catch (EXCEPTION_TYPE$\(_1\)$ * [NAME$\(_1\)$]) {
         HANDLER_BLOCK$\(_1\)$
 } catch (EXCEPTION_TYPE$\(_2\)$ * NAME$\(_2\)$) {
+} catch (EXCEPTION_TYPE$\(_2\)$ * [NAME$\(_2\)$]) {
         HANDLER_BLOCK$\(_2\)$
+}
 \end{cfa}
 When viewed on its own a try statement will simply exceute the statements in
 @GUARDED_BLOCK@ and when those are finished the try statement finishes.
+When viewed on its own, a try statement will simply execute the statements
+in @GUARDED_BLOCK@ and when those are finished the try statement finishes.
 However, while the guarded statements are being executed, including any
+functions they invoke, all the handlers following the try block are now
+or any functions invoked from those
+statements, throws an exception, and the exception
+is not handled by a try statement further up the stack, the termination
+handlers are searched for a matching exception type from top to bottom.
+Exception matching checks the representation of the thrown exception-type is
+the same or a descendant type of the exception types in the handler clauses. If
+it is the same of a descendent of @EXCEPTION_TYPE@$_i$ then @NAME@$_i$ is
+invoked functions, all the handlers in the statement are now on the search
+path. If a termination exception is thrown and not handled further up the
+stack they will be matched against the exception.
+Exception matching checks the handler in each catch clause in the order
+they appear, top to bottom. If the representation of the thrown exception type
+is the same or a descendant of @EXCEPTION_TYPE@$_i$ then @NAME@$_i$
+(if provided) is
 bound to a pointer to the exception and the statements in @HANDLER_BLOCK@$_i$
 are executed. If control reaches the end of the handler, the exception is
 freed and control continues after the try statement.
+If no handler is found during the search then the default handler is run.
+If no termination handler is found during the search then the default handler
+(@defaultTerminationHandler@) is run.
 Through \CFA's trait system the best match at the throw sight will be used.
 This function is run and is passed the copied exception. After the default
 handler is run control continues after the throw statement.
+There is a global @defaultTerminationHandler@ that cancels the current stack
+with the copied exception. However it is generic over all exception types so
+new default handlers can be defined for different exception types and so
+different exception types can have different default handlers.
+There is a global @defaultTerminationHandler@ that is polymorphic over all
+exception types. Since it is so general a more specific handler can be
+defined and will be used for those types, effectively overriding the handler
+for particular exception type.
+The global default termination handler performs a cancellation
+\see{\VRef{s:Cancellation}} on the current stack with the copied exception.
 \subsection{Resumption}
 \label{s:Resumption}
 Resumption exception handling is a less common form than termination but is
 just as old~\cite{Goodenough75} and is in some sense simpler.
 It is a dynamic, non-local function call. If the throw is successful a
+closure will be taken from up the stack and executed, after which the throwing
 function will continue executing.
 These are most often used when an error occured and if the error is repaired
+Resumption exception handling is less common than termination but is
+just as old~\cite{Goodenough75} and is simpler in many ways.
+It is a dynamic, non-local function call. If the raised exception is
+matched a closure will be taken from up the stack and executed,
+after which the raising function will continue executing.
+These are most often used when an error occurred and if the error is repaired
 then the function can continue.
 …
 throwResume EXPRESSION;
 \end{cfa}
+The semantics of the @throwResume@ statement are like the @throw@, but the
+expression has return a reference a type that satifies the trait
+@is_resumption_exception@. The assertions from this trait are available to
+It works much the same way as the termination throw.
+The expression must return a reference to a resumption exception,
+where the resumption exception is any type that satisfies the trait
+@is_resumption_exception@ at the call site.
+The assertions from this trait are available to
 the exception system while handling the exception.
+At runtime, no copies are made. As the stack is not unwound the exception and
+At run-time, no exception copy is made.
+As the stack is not unwound the exception and
 any values on the stack will remain in scope while the resumption is handled.
+Then the exception system searches the stack using the provided exception.
+It starts starts from the throw and proceeds to the base of the stack,
+from callee to caller.
+The EHM then begins propogation. The search starts from the raise in the
+resuming function and proceeds to the base of the stack, from callee to caller.
 At each stack frame, a check is made for resumption handlers defined by the
 @catchResume@ clauses of a @try@ statement.
 …
 try {
         GUARDED_BLOCK
 } catchResume (EXCEPTION_TYPE$\(_1\)$ * NAME$\(_1\)$) {
+} catchResume (EXCEPTION_TYPE$\(_1\)$ * [NAME$\(_1\)$]) {
         HANDLER_BLOCK$\(_1\)$
 } catchResume (EXCEPTION_TYPE$\(_2\)$ * NAME$\(_2\)$) {
+} catchResume (EXCEPTION_TYPE$\(_2\)$ * [NAME$\(_2\)$]) {
         HANDLER_BLOCK$\(_2\)$
+}
 \end{cfa}
+If the handlers are not involved in a search this will simply execute the
+@GUARDED_BLOCK@ and then continue to the next statement.
+Its purpose is to add handlers onto the stack.
+(Note, termination and resumption handlers may be intermixed in a @try@
+statement but the kind of throw must be the same as the handler for it to be
+considered as a possible match.)
+If a search for a resumption handler reaches a try block it will check each
+@catchResume@ clause, top-to-bottom.
+At each handler if the thrown exception is or is a child type of
+@EXCEPTION_TYPE@$_i$ then the a pointer to the exception is bound to
+@NAME@$_i$ and then @HANDLER_BLOCK@$_i$ is executed. After the block is
+finished control will return to the @throwResume@ statement.
+% I wonder if there would be some good central place for this.
+Note that termination handlers and resumption handlers may be used together
+in a single try statement, intermixing @catch@ and @catchResume@ freely.
+Each type of handler will only interact with exceptions from the matching
+type of raise.
+When a try statement is executed it simply executes the statements in the
+@GUARDED_BLOCK@ and then finishes.
+However, while the guarded statements are being executed, including any
+invoked functions, all the handlers in the statement are now on the search
+path. If a resumption exception is reported and not handled further up the
+stack they will be matched against the exception.
+Exception matching checks the handler in each catch clause in the order
+they appear, top to bottom. If the representation of the thrown exception type
+is the same or a descendant of @EXCEPTION_TYPE@$_i$ then @NAME@$_i$
+(if provided) is bound to a pointer to the exception and the statements in
+@HANDLER_BLOCK@$_i$ are executed.
+If control reaches the end of the handler, execution continues after the
+the raise statement that raised the handled exception.
 Like termination, if no resumption handler is found, the default handler
 …
 call sight according to \CFA's overloading rules. The default handler is
 passed the exception given to the throw. When the default handler finishes
 execution continues after the throw statement.
+execution continues after the raise statement.
 There is a global @defaultResumptionHandler@ is polymorphic over all
 termination exceptions and preforms a termination throw on the exception.
 The @defaultTerminationHandler@ for that throw is matched at the original
 throw statement (the resumption @throwResume@) and it can be customized by
+The @defaultTerminationHandler@ for that raise is matched at the original
+raise statement (the resumption @throwResume@) and it can be customized by
 introducing a new or better match as well.
+% \subsubsection?
+\subsubsection{Resumption Marking}
 A key difference between resumption and termination is that resumption does
 not unwind the stack. A side effect that is that when a handler is matched
 …
 search and match the handler in the @catchResume@ clause. This will be
 call and placed on the stack on top of the try-block. The second throw then
 throws and will seach the same try block and put call another instance of the
+throws and will search the same try block and put call another instance of the
 same handler leading to an infinite loop.
 …
 can form with multiple handlers and different exception types.
+To prevent all of these cases we mask sections of the stack, or equvilantly
+the try statements on the stack, so that the resumption seach skips over
+them and continues with the next unmasked section of the stack.
+A section of the stack is marked when it is searched to see if it contains
+a handler for an exception and unmarked when that exception has been handled
+or the search was completed without finding a handler.
+% This might need a diagram. But it is an important part of the justification
+% of the design of the traversal order.
+\begin{verbatim}
+       throwResume2 ----------.
+            |                 |
+ generated from handler       |
+            |                 |
+         handler              |
+            |                 |
+        throwResume1 -----.   :
+            |             |   :
+           try            |   : search skip
+            |             |   :
+        catchResume  <----'   :
+            |                 |
+\end{verbatim}
+The rules can be remembered as thinking about what would be searched in
+termination. So when a throw happens in a handler; a termination handler
+skips everything from the original throw to the original catch because that
+part of the stack has been unwound, a resumption handler skips the same
+section of stack because it has been masked.
+A throw in a default handler will preform the same search as the original
+throw because; for termination nothing has been unwound, for resumption
+the mask will be the same.
+The symmetry with termination is why this pattern was picked. Other patterns,
+such as marking just the handlers that caught, also work but lack the
+symmetry whih means there is more to remember.
+To prevent all of these cases we mark try statements on the stack.
+A try statement is marked when a match check is preformed with it and an
+exception. The statement will be unmarked when the handling of that exception
+is completed or the search completes without finding a handler.
+While a try statement is marked its handlers are never matched, effectify
+skipping over it to the next try statement.
+\begin{center}
+\input{stack-marking}
+\end{center}
+These rules mirror what happens with termination.
+When a termination throw happens in a handler the search will not look at
+any handlers from the original throw to the original catch because that
+part of the stack has been unwound.
+A resumption raise in the same situation wants to search the entire stack,
+but it will not try to match the exception with try statements in the section
+that would have been unwound as they are marked.
+The symmetry between resumption termination is why this pattern was picked.
+Other patterns, such as marking just the handlers that caught, also work but
+lack the symmetry means there are less rules to remember.
 \section{Conditional Catch}
 …
 condition to further control which exceptions they handle:
 \begin{cfa}
 catch (EXCEPTION_TYPE * NAME ; CONDITION)
+catch (EXCEPTION_TYPE * [NAME] ; CONDITION)
 \end{cfa}
 First, the same semantics is used to match the exception type. Second, if the
 …
 matches. Otherwise, the exception search continues as if the exception type
 did not match.
+\begin{cfa}
+try {
+        f1 = open( ... );
+        f2 = open( ... );
+The condition matching allows finer matching by allowing the match to check
+more kinds of information than just the exception type.
+\begin{cfa}
+try {
+        handle1 = open( f1, ... );
+        handle2 = open( f2, ... );
+        handle3 = open( f3, ... );
         ...
 } catch( IOFailure * f ; fd( f ) == f1 ) {
+        // only handle IO failure for f1
+}
+\end{cfa}
+Note, catching @IOFailure@, checking for @f1@ in the handler, and reraising the
+exception if not @f1@ is different because the reraise does not examine any of
+remaining handlers in the current try statement.
+\section{Rethrowing}
+\colour{red}{From Andrew: I recomend we talk about why the language doesn't
+have rethrows/reraises instead.}
+\label{s:Rethrowing}
+        // Only handle IO failure for f1.
+} catch( IOFailure * f ; fd( f ) == f3 ) {
+        // Only handle IO failure for f3.
+}
+// Can't handle a failure relating to f2 here.
+\end{cfa}
+In this example the file that experianced the IO error is used to decide
+which handler should be run, if any at all.
+\begin{comment}
+% I know I actually haven't got rid of them yet, but I'm going to try
+% to write it as if I had and see if that makes sense:
+\section{Reraising}
+\label{s:Reraising}
 Within the handler block or functions called from the handler block, it is
 possible to reraise the most recently caught exception with @throw@ or
 …
 is part of an unwound stack frame. To prevent this problem, a new default
 handler is generated that does a program-level abort.
+\end{comment}
+\subsection{Comparison with Reraising}
+A more popular way to allow handlers to match in more detail is to reraise
+the exception after it has been caught if it could not be handled here.
+On the surface these two features seem interchangable.
+If we used @throw;@ to start a termination reraise then these two statements
+would have the same behaviour:
+\begin{cfa}
+try {
+    do_work_may_throw();
+} catch(exception_t * exc ; can_handle(exc)) {
+    handle(exc);
+}
+\end{cfa}
+\begin{cfa}
+try {
+    do_work_may_throw();
+} catch(exception_t * exc) {
+    if (can_handle(exc)) {
+        handle(exc);
+    } else {
+        throw;
+    }
+}
+\end{cfa}
+If there are further handlers after this handler only the first version will
+check them. If multiple handlers on a single try block could handle the same
+exception the translations get more complex but they are equivilantly
+powerful.
+Until stack unwinding comes into the picture. In termination handling, a
+conditional catch happens before the stack is unwound, but a reraise happens
+afterwards. Normally this might only cause you to loose some debug
+information you could get from a stack trace (and that can be side stepped
+entirely by collecting information during the unwind). But for \CFA there is
+another issue, if the exception isn't handled the default handler should be
+run at the site of the original raise.
+There are two problems with this: the site of the original raise doesn't
+exist anymore and the default handler might not exist anymore. The site will
+always be removed as part of the unwinding, often with the entirety of the
+function it was in. The default handler could be a stack allocated nested
+function removed during the unwind.
+This means actually trying to pretend the catch didn't happening, continuing
+the original raise instead of starting a new one, is infeasible.
+That is the expected behaviour for most languages and we can't replicate
+that behaviour.
 \section{Finally Clauses}
+\label{s:FinallyClauses}
 Finally clauses are used to preform unconditional clean-up when leaving a
 scope. They are placed at the end of a try statement:
+scope and are placed at the end of a try statement after any handler clauses:
 \begin{cfa}
 try {
 …
 Execution of the finally block should always finish, meaning control runs off
+the end of the block. This requirement ensures always continues as if the
+finally clause is not present, \ie finally is for cleanup not changing control
+flow. Because of this requirement, local control flow out of the finally block
+the end of the block. This requirement ensures control always continues as if
+the finally clause is not present, \ie finally is for cleanup not changing
+control flow.
+Because of this requirement, local control flow out of the finally block
 is forbidden. The compiler precludes any @break@, @continue@, @fallthru@ or
 @return@ that causes control to leave the finally block. Other ways to leave
 the finally block, such as a long jump or termination are much harder to check,
 and at best requiring additional run-time overhead, and so are mearly
+and at best requiring additional run-time overhead, and so are only
 discouraged.
 Not all languages with exceptions have finally clauses. Notably \Cpp does
+Not all languages with unwinding have finally clauses. Notably \Cpp does
 without it as descructors serve a similar role. Although destructors and
 finally clauses can be used in many of the same areas they have their own
 use cases like top-level functions and lambda functions with closures.
 Destructors take a bit more work to set up but are much easier to reuse while
+finally clauses are good for once offs and can include local information.
+finally clauses are good for one-off uses and
+can easily include local information.
 \section{Cancellation}
+\label{s:Cancellation}
 Cancellation is a stack-level abort, which can be thought of as as an
 uncatchable termination. It unwinds the entirety of the current stack, and if
+uncatchable termination. It unwinds the entire current stack, and if
 possible forwards the cancellation exception to a different stack.
 …
 There is no special statement for starting a cancellation; instead the standard
 library function @cancel_stack@ is called passing an exception. Unlike a
 throw, this exception is not used in matching only to pass information about
+raise, this exception is not used in matching only to pass information about
 the cause of the cancellation.
 (This also means matching cannot fail so there is no default handler either.)
 After @cancel_stack@ is called the exception is copied into the exception
 handling mechanism's memory. Then the entirety of the current stack is
+(This also means matching cannot fail so there is no default handler.)
+After @cancel_stack@ is called the exception is copied into the EHM's memory
+and the current stack is
 unwound. After that it depends one which stack is being cancelled.
 \begin{description}
 \item[Main Stack:]
 The main stack is the one used by the program main at the start of execution,
+and is the only stack in a sequential program. Even in a concurrent program
+the main stack is only dependent on the environment that started the program.
+Hence, when the main stack is cancelled there is nowhere else in the program
+to notify. After the stack is unwound, there is a program-level abort.
+and is the only stack in a sequential program.
+After the main stack is unwound there is a program-level abort.
+There are two reasons for this. The first is that it obviously had to do this
+in a sequential program as there is nothing else to notify and the simplicity
+of keeping the same behaviour in sequential and concurrent programs is good.
+Also, even in concurrent programs there is no stack that an innate connection
+to, so it would have be explicitly managed.
 \item[Thread Stack:]
+A thread stack is created for a @thread@ object or object that satisfies the
+@is_thread@ trait. A thread only has two points of communication that must
+happen: start and join. As the thread must be running to perform a
+cancellation, it must occur after start and before join, so join is used
+for communication here.
+After the stack is unwound, the thread halts and waits for
+another thread to join with it. The joining thread checks for a cancellation,
+and if present, resumes exception @ThreadCancelled@.
+There is a subtle difference between the explicit join (@join@ function) and
+implicit join (from a destructor call). The explicit join takes the default
+handler (@defaultResumptionHandler@) from its calling context, which is used if
+the exception is not caught. The implicit join does a program abort instead.
+This semantics is for safety. If an unwind is triggered while another unwind
+is underway only one of them can proceed as they both want to ``consume'' the
+stack. Letting both try to proceed leads to very undefined behaviour.
+Both termination and cancellation involve unwinding and, since the default
+@defaultResumptionHandler@ preforms a termination that could more easily
+happen in an implicate join inside a destructor. So there is an error message
+and an abort instead.
+\todo{Perhaps have a more general disucssion of unwind collisions before
+this point.}
+The recommended way to avoid the abort is to handle the intial resumption
+from the implicate join. If required you may put an explicate join inside a
+finally clause to disable the check and use the local
+@defaultResumptionHandler@ instead.
+\item[Coroutine Stack:] A coroutine stack is created for a @coroutine@ object
+or object that satisfies the @is_coroutine@ trait. A coroutine only knows of
+two other coroutines, its starter and its last resumer. Of the two the last
+resumer has the tightest coupling to the coroutine it activated and the most
+up-to-date information.
+Hence, cancellation of the active coroutine is forwarded to the last resumer
+after the stack is unwound. When the resumer restarts, it resumes exception
+@CoroutineCancelled@, which is polymorphic over the coroutine type and has a
+pointer to the cancelled coroutine.
+The resume function also has an assertion that the @defaultResumptionHandler@
+for the exception. So it will use the default handler like a regular throw.
+A thread stack is created for a \CFA @thread@ object or object that satisfies
+the @is_thread@ trait.
+After a thread stack is unwound there exception is stored until another
+thread attempts to join with it. Then the exception @ThreadCancelled@,
+which stores a reference to the thread and to the exception passed to the
+cancellation, is reported from the join.
+There is one difference between an explicit join (with the @join@ function)
+and an implicit join (from a destructor call). The explicit join takes the
+default handler (@defaultResumptionHandler@) from its calling context while
+the implicit join provides its own which does a program abort if the
+@ThreadCancelled@ exception cannot be handled.
+Communication is done at join because a thread only has to have to points of
+communication with other threads: start and join.
+Since a thread must be running to perform a cancellation (and cannot be
+cancelled from another stack), the cancellation must be after start and
+before the join. So join is the one that we will use.
+% TODO: Find somewhere to discuss unwind collisions.
+The difference between the explicit and implicit join is for safety and
+debugging. It helps prevent unwinding collisions by avoiding throwing from
+a destructor and prevents cascading the error across multiple threads if
+the user is not equipped to deal with it.
+Also you can always add an explicit join if that is the desired behaviour.
+\item[Coroutine Stack:]
+A coroutine stack is created for a @coroutine@ object or object that
+satisfies the @is_coroutine@ trait.
+After a coroutine stack is unwound control returns to the resume function
+that most recently resumed it. The resume statement reports a
+@CoroutineCancelled@ exception, which contains a references to the cancelled
+coroutine and the exception used to cancel it.
+The resume function also takes the @defaultResumptionHandler@ from the
+caller's context and passes it to the internal report.
+A coroutine knows of two other coroutines, its starter and its last resumer.
+The starter has a much more distant connection while the last resumer just
+(in terms of coroutine state) called resume on this coroutine, so the message
+is passed to the latter.
 \end{description}

doc/theses/andrew_beach_MMath/future.tex

-              rfeacef9
+              r5407cdc
 patterns to find the handler.
+\section{Checked Exceptions}
+Checked exceptions make exceptions part of a function's type by adding the
+exception signature. An exception signature must declare all checked
+exceptions that could propogate from the function (either because they were
+raised inside the function or came from a sub-function). This improves safety
+by making sure every checked exception is either handled or consciously
+passed on.
+However checked exceptions were never seriously considered for this project
+for two reasons. The first is due to time constraints, even copying an
+existing checked exception system would be pushing the remaining time and
+trying to address the second problem would take even longer. The second
+problem is that checked exceptions have some real usability trade-offs in
+exchange for the increased safety.
+These trade-offs are most problematic when trying to pass exceptions through
+higher-order functions from the functions the user passed into the
+higher-order function. There are no well known solutions to this problem
+that were statifactory for \CFA (which carries some of C's flexability
+over safety design) so one would have to be researched and developed.
+Follow-up work might add checked exceptions to \CFA, possibly using
+polymorphic exception signatures, a form of tunneling\cite{Zhang19} or
+checked and unchecked raises.
 \section{Zero-Cost Try}
 \CFA does not have zero-cost try-statements because the compiler generates C

doc/theses/andrew_beach_MMath/implement.tex

-              rfeacef9
+              r5407cdc
 library.
+\subsection{Virtual Type}
+Virtual types only have one change to their structure, the addition of a
+pointer to the virtual table. This is always the first field so that
+if it is cast to a supertype the field's location is still known.
+This field is set as part of all new generated constructors.
+\todo{They only come as part exceptions and don't work.}
+After the object is created the field is constant.
+However it can be read from, internally it is just a regular field called
+@virtual_table@. Dereferencing it gives the virtual table and access to the
+type's virtual members.
 \subsection{Virtual Table}
+Every time a virtual type is defined the new virtual table type must also be
+defined.
+The unique instance is important because the address of the virtual table
+instance is used as the identifier for the virtual type. So a pointer to the
+virtual table and the ID for the virtual type are interchangable.
+\todo{Unique instances might be going so we will have to talk about the new
+system instead.}
+The first step in putting it all together is to create the virtual table type.
+The virtual table type is just a structure and can be described in terms of
+its fields. The first field is always the parent type ID (or a pointer to
+the parent virtual table) or 0 (the null pointer).
+Next are other fields on the parent virtual table are repeated.
+Finally are the fields used to store any new virtual members of the new
+The virtual type
 The virtual system is accessed through a private constant field inserted at the
 beginning of every virtual type, called the virtual-table pointer. This field
 points at a type's virtual table and is assigned during the object's
 construction.  The address of a virtual table acts as the unique identifier for
+construction. The address of a virtual table acts as the unique identifier for
 the virtual type, and the first field of a virtual table is a pointer to the
 parent virtual-table or @0p@.  The remaining fields are duplicated from the
+parent virtual-table or @0p@. The remaining fields are duplicated from the
 parent tables in this type's inheritance chain, followed by any fields this type
 introduces. Parent fields are duplicated so they can be changed (\CC
 \lstinline[language=c++]|override|), so that references to the dispatched type
+introduces. Parent fields are duplicated so they can be changed (all virtual
+members are overridable), so that references to the dispatched type
 are replaced with the current virtual type.
-\PAB{Can you create a simple diagram of the layout?}
 % These are always taken by pointer or reference.
+% Simple ascii diragram:
+\begin{verbatim}
+parent_pointer  \
+parent_field0   |
+...             | Same layout as parent.
+parent_fieldN   /
+child_field0
+...
+child_fieldN
+\end{verbatim}
+\todo{Refine the diagram}
 % For each virtual type, a virtual table is constructed. This is both a new type
 …
 A virtual table is created when the virtual type is created. The name of the
 type is created by mangling the name of the base type. The name of the instance
 is also generated by name mangling.  The fields are initialized automatically.
+is also generated by name mangling. The fields are initialized automatically.
 The parent field is initialized by getting the type of the parent field and
 using that to calculate the mangled name of the parent's virtual table type.
 …
 \begin{sloppypar}
 Coroutines and threads need instances of @CoroutineCancelled@ and
 @ThreadCancelled@ respectively to use all of their functionality.  When a new
+@ThreadCancelled@ respectively to use all of their functionality. When a new
 data type is declared with @coroutine@ or @thread@ the forward declaration for
 the instance is created as well. The definition of the virtual table is created
 …
 The function is
 \begin{cfa}
+void * __cfa__virtual_cast( struct __cfa__parent_vtable const * parent,
+void * __cfa__virtual_cast(
+        struct __cfa__parent_vtable const * parent,
         struct __cfa__parent_vtable const * const * child );
+}
 \end{cfa}
+and it is implemented in the standard library. It takes a pointer to the target
+type's virtual table and the object pointer being cast. The function performs a
+linear search starting at the object's virtual-table and walking through the
+the parent pointers, checking to if it or any of its ancestors are the same as
+the target-type virtual table-pointer.
+For the generated code, a forward declaration of the virtual works as follows.
+There is a forward declaration of @__cfa__virtual_cast@ in every \CFA file so
+it can just be used. The object argument is the expression being cast so that
+is just placed in the argument list.
+To build the target type parameter, the compiler creates a mapping from
+concrete type-name -- so for polymorphic types the parameters are filled in --
+to virtual table address. Every virtual table declaration is added to the this
+table; repeats are ignored unless they have conflicting definitions.  Note,
+these declarations do not have to be in scope, but they should usually be
+introduced as part of the type definition.
+\PAB{I do not understood all of \VRef{s:VirtualSystem}. I think you need to
+write more to make it clear.}
+and it is implemented in the standard library. The structure reperents the
+head of a vtable which is the pointer to the parent virtual table. The
+@parent@ points directly at the parent type virtual table while the @child@
+points at the object of the (possibe) child type.
+In terms of the virtual cast expression, @parent@ comes from looking up the
+type being cast to and @child@ is the result of the expression being cast.
+Because the complier outputs C code, some type C type casts are also used.
+The last bit of glue is an map that saves every virtual type the compiler
+sees. This is used to check the type used in a virtual cast is a virtual
+type and to get its virtual table.
+(It also checks for conflicting definitions.)
+Inside the function it is a simple conditional. If the type repersented by
+@parent@ is or is an ancestor of the type repersented by @*child@ (it
+requires one more level of derefence to pass through the object) then @child@
+is returned, otherwise the null pointer is returned.
+The check itself is preformed is a simple linear search. If the child
+virtual table or any of its ancestors (which are retreved through the first
+field of every virtual table) are the same as the parent virtual table then
+the cast succeeds.
 \section{Exceptions}
 …
 stack. On function entry and return, unwinding is handled directly by the code
 embedded in the function. Usually, the stack-frame size is known statically
 based on parameter and local variable declarations.  For dynamically-sized
+based on parameter and local variable declarations. For dynamically-sized
 local variables, a runtime computation is necessary to know the frame
 size. Finally, a function's frame-size may change during execution as local
 …
 To use libunwind, each function must have a personality function and a Language
 Specific Data Area (LSDA).  The LSDA has the unique information for each
+Specific Data Area (LSDA). The LSDA has the unique information for each
 function to tell the personality function where a function is executing, its
 current stack frame, and what handlers should be checked.  Theoretically, the
+current stack frame, and what handlers should be checked. Theoretically, the
 LSDA can contain any information but conventionally it is a table with entries
 representing regions of the function and what has to be done there during
 …
 The GCC compilation flag @-fexceptions@ causes the generation of an LSDA and
+attaches its personality function. \PAB{to what is it attached?}  However, this
+flag only handles the cleanup attribute
+attaches its personality function. However, this
+flag only handles the cleanup attribute:
+\todo{Peter: What is attached? Andrew: It uses the .cfi\_personality directive
+and that's all I know.}
 \begin{cfa}
 void clean_up( int * var ) { ... }
 int avar __attribute__(( __cleanup(clean_up) ));
+int avar __attribute__(( cleanup(clean_up) ));
 \end{cfa}
+which is used on a variable and specifies a function, \eg @clean_up@, run when
+the variable goes out of scope. The function is passed a pointer to the object
+so it can be used to mimic destructors. However, this feature cannot be used to
+mimic @try@ statements.
+which is used on a variable and specifies a function, in this case @clean_up@,
+run when the variable goes out of scope.
+The function is passed a pointer to the object being removed from the stack
+so it can be used to mimic destructors.
+However, this feature cannot be used to mimic @try@ statements as it cannot
+control the unwinding.
 \subsection{Personality Functions}
 Personality functions have a complex interface specified by libunwind.  This
+Personality functions have a complex interface specified by libunwind. This
 section covers some of the important parts of the interface.
 A personality function performs four tasks, although not all have to be
 present.
+A personality function can preform different actions depending on how it is
+called.
 \begin{lstlisting}[language=C,{moredelim=**[is][\color{red}]{@}{@}}]
 typedef _Unwind_Reason_Code (*@_Unwind_Personality_Fn@) (
 …
 \item
 @_UA_SEARCH_PHASE@ specifies a search phase and tells the personality function
 to check for handlers.  If there is a handler in a stack frame, as defined by
+to check for handlers. If there is a handler in a stack frame, as defined by
 the language, the personality function returns @_URC_HANDLER_FOUND@; otherwise
 it return @_URC_CONTINUE_UNWIND@.
 …
 \end{cfa}
 It also unwinds the stack but it does not use the search phase. Instead another
 function, the stop function, is used to stop searching.  The exception is the
+function, the stop function, is used to stop searching. The exception is the
 same as the one passed to raise exception. The extra arguments are the stop
 function and the stop parameter. The stop function has a similar interface as a
 …
 \begin{sloppypar}
 Its arguments are the same as the paired personality function.  The actions
+Its arguments are the same as the paired personality function. The actions
 @_UA_CLEANUP_PHASE@ and @_UA_FORCE_UNWIND@ are always set when it is
 called. Beyond the libunwind standard, both GCC and Clang add an extra action
 …
 strong symbol replacing the sequential version.
+% The version of the function defined in @libcfa@ is very simple. It returns a
+% pointer to a global static variable. With only one stack this global instance
+% is associated with the only stack.
+For coroutines, @this_exception_context@ accesses the exception context stored
+at the base of the stack. For threads, @this_exception_context@ uses the
+concurrency library to access the current stack of the thread or coroutine
+being executed by the thread, and then accesses the exception context stored at
+the base of this stack.
+The sequential @this_exception_context@ returns a hard-coded pointer to the
+global execption context.
+The concurrent version adds the exception context to the data stored at the
+base of each stack. When @this_exception_context@ is called it retrieves the
+active stack and returns the address of the context saved there.
 \section{Termination}
 …
 per-exception storage.
+Exceptions are stored in variable-sized blocks. \PAB{Show a memory layout
+figure.} The first component is a fixed sized data structure that contains the
+[Quick ASCII diagram to get started.]
+\begin{verbatim}
+Fixed Header  | _Unwind_Exception   <- pointer target
+              |
+              | Cforall storage
+              |
+Variable Body | the exception       <- fixed offset
+              V ...
+\end{verbatim}
+Exceptions are stored in variable-sized blocks.
+The first component is a fixed sized data structure that contains the
 information for libunwind and the exception system. The second component is an
 area of memory big enough to store the exception. Macros with pointer arthritic
 …
 exception type. The size and copy function are used immediately to copy an
 exception into managed memory. After the exception is handled the free function
+is used to clean up the exception and then the entire node is passed to free.
+is used to clean up the exception and then the entire node is passed to free
+so the memory can be given back to the heap.
 \subsection{Try Statements and Catch Clauses}
 …
 library. The contents of a try block and the termination handlers are converted
 into functions. These are then passed to the try terminate function and it
+calls them. This approach puts a try statement in its own functions so that no
+function has to deal with both termination handlers and destructors. \PAB{I do
+not understand the previous sentence.}
+This function has some custom embedded assembly that defines \emph{its}
+personality function and LSDA. The assembly is created with handcrafted C @asm@
+statements, which is why there is only one version of it. The personality
+function is structured so that it can be expanded, but currently it only
+handles this one function.  Notably, it does not handle any destructors so the
+function is constructed so that it does need to run it. \PAB{I do not
+understand the previous sentence.}
+calls them.
+Because this function is known and fixed (and not an arbitrary function that
+happens to contain a try statement) this means the LSDA can be generated ahead
+of time.
+Both the LSDA and the personality function are set ahead of time using
+embedded assembly. This is handcrafted using C @asm@ statements and contains
+enough information for the single try statement the function repersents.
 The three functions passed to try terminate are:
 …
 \item[match function:] This function is called during the search phase and
 decides if a catch clause matches the termination exception.  It is constructed
+decides if a catch clause matches the termination exception. It is constructed
 from the conditional part of each handler and runs each check, top to bottom,
 in turn, first checking to see if the exception type matches and then if the
 …
 \item[handler function:] This function handles the exception. It takes a
 pointer to the exception and the handler's id and returns nothing. It is called
 after the cleanup phase.  It is constructed by stitching together the bodies of
+after the cleanup phase. It is constructed by stitching together the bodies of
 each handler and dispatches to the selected handler.
 \end{description}
 …
 can be used to create closures, functions that can refer to the state of other
 functions on the stack. This approach allows the functions to refer to all the
 variables in scope for the function containing the @try@ statement.  These
+variables in scope for the function containing the @try@ statement. These
 nested functions and all other functions besides @__cfaehm_try_terminate@ in
 \CFA use the GCC personality function and the @-fexceptions@ flag to generate
 …
 handler that matches. If no handler matches then the function returns
 false. Otherwise the matching handler is run; if it completes successfully, the
 function returns true. Reresume, through the @throwResume;@ statement, cause
 the function to return true.
+function returns true. Rethrowing, through the @throwResume;@ statement,
+causes the function to return true.
 % Recursive Resumption Stuff:
 …
 providing zero-cost enter/exit using the LSDA. Unfortunately, there is no way
 to return from a libunwind search without installing a handler or raising an
 error.  Although workarounds might be possible, they are beyond the scope of
+error. Although workarounds might be possible, they are beyond the scope of
 this thesis. The current resumption implementation has simplicity in its
 favour.
 …
 Cancellation also uses libunwind to do its stack traversal and unwinding,
 however it uses a different primary function @_Unwind_ForcedUnwind@.  Details
+however it uses a different primary function @_Unwind_ForcedUnwind@. Details
 of its interface can be found in the \VRef{s:ForcedUnwind}.
 …
 its main coroutine and the coroutine it is currently executing.
+The first check is if the current thread's main and current coroutine do not
+match, implying a coroutine cancellation; otherwise, it is a thread
+cancellation. Otherwise it is a main thread cancellation. \PAB{Previous
+sentence does not make sense.}
+So if the active thread's main and current coroutine are the same. If they
+are then the current stack is a thread stack, otherwise it is a coroutine
+stack. If it is a thread stack then an equality check with the stored main
+thread pointer and current thread pointer is enough to tell if the current
+thread is the main thread or not.
 However, if the threading library is not linked, the sequential execution is on

doc/theses/andrew_beach_MMath/uw-ethesis.tex

-              rfeacef9
+              r5407cdc
 % ======================================================================
 %   D O C U M E N T   P R E A M B L E
+% Specify the document class, default style attributes, page dimensions, etc.
+% For hyperlinked PDF, suitable for viewing on a computer, use this:
+\documentclass[letterpaper,12pt,titlepage,oneside,final]{book}
+% For PDF, suitable for double-sided printing, change the PrintVersion
+% variable below to "true" and use this \documentclass line instead of the
+% one above:
+%\documentclass[letterpaper,12pt,titlepage,openright,twoside,final]{book}
+\usepackage{etoolbox}
+\RequirePackage{etoolbox}
+% Control if this for print (set true) or will stay digital (default).
+% Print is two sided, digital uses more colours.
+\newtoggle{printversion}
+%\toggletrue{printversion}
+\iftoggle{printversion}{%
+  \documentclass[letterpaper,12pt,titlepage,openright,twoside,final]{book}
+}{%
+  \documentclass[letterpaper,12pt,titlepage,oneside,final]{book}
+}
 % Some LaTeX commands I define for my own nomenclature.
 …
 % Anything defined here may be redefined by packages added below...
+% This package allows if-then-else control structures.
+\usepackage{ifthen}
+\newboolean{PrintVersion}
+\setboolean{PrintVersion}{false}
+% CHANGE THIS VALUE TO "true" as necessary, to improve printed results for
+% hard copies by overriding some options of the hyperref package, called below.
+%\usepackage{nomencl} % For a nomenclature (optional; available from ctan.org)
+% For a nomenclature (optional; available from ctan.org)
+%\usepackage{nomencl}
 % Lots of math symbols and environments
 \usepackage{amsmath,amssymb,amstext}
+% For including graphics N.B. pdftex graphics driver
+\usepackage[pdftex]{graphicx}
+% For including graphics (must match graphics driver)
+\usepackage{epic,eepic}
+\usepackage{graphicx}
 % Removes large sections of the document.
 \usepackage{comment}
 % Adds todos (Must be included after comment.)
 \usepackage{todonotes}
 % Hyperlinks make it very easy to navigate an electronic document.
 …
 % Use the "hyperref" package
 % N.B. HYPERREF MUST BE THE LAST PACKAGE LOADED; ADD ADDITIONAL PKGS ABOVE
+\usepackage[pdftex,pagebackref=true]{hyperref} % with basic options
+%\usepackage[pdftex,pagebackref=true]{hyperref}
+\usepackage[pagebackref=true]{hyperref}
 % N.B. pagebackref=true provides links back from the References to the body
 % text. This can cause trouble for printing.
 …
     pdffitwindow=false,     % window fit to page when opened
     pdfstartview={FitH},    % fits the width of the page to the window
-%    pdftitle={uWaterloo\ LaTeX\ Thesis\ Template}, % title: CHANGE THIS TEXT!
-%    pdfauthor={Author},    % author: CHANGE THIS TEXT! and uncomment this line
-%    pdfsubject={Subject},  % subject: CHANGE THIS TEXT! and uncomment this line
-%    pdfkeywords={keyword1} {key2} {key3}, % optional list of keywords
     pdfnewwindow=true,      % links in new window
     colorlinks=true,        % false: boxed links; true: colored links
-    linkcolor=blue,         % color of internal links
-    citecolor=green,        % color of links to bibliography
-    filecolor=magenta,      % color of file links
-    urlcolor=cyan           % color of external links
+}
+% for improved print quality, change some hyperref options
+\ifthenelse{\boolean{PrintVersion}}{
+\hypersetup{    % override some previously defined hyperref options
+%    colorlinks,%
+    citecolor=black,%
+    filecolor=black,%
+    linkcolor=black,%
+    urlcolor=black}
+}{} % end of ifthenelse (no else)
+\iftoggle{printversion}{
+  \hypersetup{
+    citecolor=black,        % colour of links to bibliography
+    filecolor=black,        % colour of file links
+    linkcolor=black,        % colour of internal links
+    urlcolor=black,         % colour of external links
+  }
+}{ % Digital Version
+  \hypersetup{
+    citecolor=green,
+    filecolor=magenta,
+    linkcolor=blue,
+    urlcolor=cyan,
+  }
+}
+\hypersetup{
+  pdftitle={Exception Handling in Cforall},
+  pdfauthor={Andrew James Beach},
+  pdfsubject={Computer Science},
+  pdfkeywords={programming languages} {exceptions}
+      {language design} {language implementation},
+}
 % Exception to the rule of hyperref being the last add-on package
 …
 \pdfstringdefDisableCommands{\def\Cpp{C++}}
+% Wrappers for inline code snippits.
+\newrobustcmd*\codeCFA[1]{\lstinline[language=CFA]{#1}}
+\newrobustcmd*\codeC[1]{\lstinline[language=C]{#1}}
+\newrobustcmd*\codeCpp[1]{\lstinline[language=C++]{#1}}
+\newrobustcmd*\codePy[1]{\lstinline[language=Python]{#1}}
 % Colour text, formatted in LaTeX style instead of TeX style.
 \newcommand*\colour[2]{{\color{#1}#2}}

doc/theses/mubeen_zulfiqar_MMath/uw-ethesis.bib

-              rfeacef9
+              r5407cdc
                          Alexander Samarin",
         title =         "The \LaTeX\ Companion",
         year =          "1994",
+        year =          "1994",
         publisher =     "Addison-Wesley",
         address =       "Reading, Massachusetts"
+        address =       "Reading, Massachusetts"
+}
 …
         title =         "\LaTeX\ --- A Document Preparation System",
         edition =       "Second",
         year =          "1994",
         publisher =     "Addison-Wesley",
+        year =          "1994",
+        publisher =     "Addison-Wesley",
         address =       "Reading, Massachusetts"
+}

doc/theses/thierry_delisle_PhD/code/readyQ_proto/links.hpp

rfeacef9	r5407cdc
117	117	}
118	118
119		long long ts() const {
	119	unsigned long long ts() const {
120	120	return before._links.ts;
121	121	}

doc/theses/thierry_delisle_PhD/code/readyQ_proto/processor_list.hpp

-              rfeacef9
+              r5407cdc
                 while( __builtin_expect(ll.exchange(true),false) ) {
                         while(ll.load(std::memory_order_relaxed))
                                 asm volatile("pause");
+                                Pause();
+                }
                 /* paranoid */ assert(ll);
 …
                          && ready.compare_exchange_weak(copy, n + 1) )
                                 break;
                         asm volatile("pause");
+                        Pause();
+                }
 …
                 // Step 1 : make sure no writer are in the middle of the critical section
                 while(lock.load(std::memory_order_relaxed))
                         asm volatile("pause");
+                        Pause();
                 // Fence needed because we don't want to start trying to acquire the lock
 …
                 //   to simply lock their own lock and enter.
                 while(lock.load(std::memory_order_relaxed))
                         asm volatile("pause");
+                        Pause();
                 // Step 2 : lock per-proc lock
 …
                 for(uint_fast32_t i = 0; i < s; i++) {
                         while(data[i].lock.load(std::memory_order_relaxed))
                                 asm volatile("pause");
+                                Pause();
+                }

doc/theses/thierry_delisle_PhD/code/readyQ_proto/processor_list_good.cpp

rfeacef9	r5407cdc
21	21	target = (target - (target % total)) + total;
22	22	while(waiting < target)
23		~~asm volatile("pause"~~);
	23	Pause();
24	24
25	25	assert(waiting < (1ul << 60));

doc/theses/thierry_delisle_PhD/code/readyQ_proto/randbit.cpp

rfeacef9	r5407cdc
123	123	target = (target - (target % total)) + total;
124	124	while(waiting < target)
125		~~asm volatile("pause"~~);
	125	Pause();
126	126
127	127	assert(waiting < (1ul << 60));

doc/theses/thierry_delisle_PhD/code/readyQ_proto/relaxed_list.cpp

-              rfeacef9
+              r5407cdc
         std::cout << "Total ops     : " << ops << "(" << global.in << "i, " << global.out << "o, " << global.empty << "e)\n";
         #ifndef NO_STATS
                 LIST_VARIANT<Node>::stats_print(std::cout);
+                LIST_VARIANT<Node>::stats_print(std::cout, duration);
         #endif
+}
 …
                 for(Node * & node : nodes) {
+                        node = list.pop();
+                        assert(node);
+                        node = nullptr;
+                        while(!node) {
+                                node = list.pop();
+                        }
                         local.crc_out += node->value;
                         local.out++;
 …
                                 for(const auto & n : nodes) {
                                         local.valmax = max(local.valmax, size_t(n.value));
                                         local.valmin = min(local.valmin, size_t(n.value));
+                                        local.valmax = std::max(local.valmax, size_t(n.value));
+                                        local.valmin = std::min(local.valmin, size_t(n.value));
+                                }
 …
                                                 try {
                                                         arg = optarg = argv[optind];
                                                         nnodes = stoul(optarg, &len);
+                                                        nnodes = std::stoul(optarg, &len);
                                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                                 } catch(std::invalid_argument &) {
 …
                                                 try {
                                                         arg = optarg = argv[optind];
                                                         nnodes = stoul(optarg, &len);
+                                                        nnodes = std::stoul(optarg, &len);
                                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                                 } catch(std::invalid_argument &) {
 …
                                                 try {
                                                         arg = optarg = argv[optind];
                                                         nnodes = stoul(optarg, &len);
+                                                        nnodes = std::stoul(optarg, &len);
                                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                                         nslots = nnodes;
 …
                                                 try {
                                                         arg = optarg = argv[optind];
                                                         nnodes = stoul(optarg, &len);
+                                                        nnodes = std::stoul(optarg, &len);
                                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                                 } catch(std::invalid_argument &) {
 …
                                                 try {
                                                         arg = optarg = argv[optind + 1];
                                                         nslots = stoul(optarg, &len);
+                                                        nslots = std::stoul(optarg, &len);
                                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                                 } catch(std::invalid_argument &) {
 …
                         case 'd':
                                 try {
                                         duration = stod(optarg, &len);
+                                        duration = std::stod(optarg, &len);
                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                 } catch(std::invalid_argument &) {
 …
                         case 't':
                                 try {
                                         nthreads = stoul(optarg, &len);
+                                        nthreads = std::stoul(optarg, &len);
                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                 } catch(std::invalid_argument &) {
 …
                         case 'q':
                                 try {
                                         nqueues = stoul(optarg, &len);
+                                        nqueues = std::stoul(optarg, &len);
                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                 } catch(std::invalid_argument &) {

doc/theses/thierry_delisle_PhD/code/readyQ_proto/snzi-packed.hpp

-              rfeacef9
+              r5407cdc
         for(int i = 0; i < width; i++) {
                 int idx = i % hwdith;
-                std::cout << i << " -> " << idx + width << std::endl;
                 leafs[i].parent = &nodes[ idx ];
+        }
 …
         for(int i = 0; i < root; i++) {
                 int idx = (i / 2) + hwdith;
-                std::cout << i + width << " -> " << idx + width << std::endl;
                 nodes[i].parent = &nodes[ idx ];
+        }

doc/theses/thierry_delisle_PhD/code/readyQ_proto/snzi.hpp

rfeacef9	r5407cdc
159	159	std::cout << "SNZI: " << depth << "x" << width << "(" << mask - 1 << ") " << (sizeof(snzi_t::node) * (root + 1)) << " bytes" << std::endl;
160	160	for(int i = 0; i < root; i++) {
161		~~std::cout << i << " -> " << (i / base) + width << std::endl;~~
162	161	nodes[i].parent = &nodes[(i / base) + width];
163	162	}

doc/theses/thierry_delisle_PhD/code/readyQ_proto/utils.hpp

-              rfeacef9
+              r5407cdc
 #include <sys/sysinfo.h>
+#include <x86intrin.h>
+// Barrier from
+class barrier_t {
+public:
+        barrier_t(size_t total)
+                : waiting(0)
+                , total(total)
+        {}
+        void wait(unsigned) {
+                size_t target = waiting++;
+                target = (target - (target % total)) + total;
+                while(waiting < target)
+                        asm volatile("pause");
+                assert(waiting < (1ul << 60));
+        }
+private:
+        std::atomic<size_t> waiting;
+        size_t total;
+};
+// #include <x86intrin.h>
 // class Random {
 …
 };
+static inline long long rdtscl(void) {
+    unsigned int lo, hi;
+    __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
+    return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
+}
+static inline long long int rdtscl(void) {
+        #if defined( __i386 ) || defined( __x86_64 )
+                unsigned int lo, hi;
+                __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
+                return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
+        #elif defined( __aarch64__ ) || defined( __arm__ )
+                // https://github.com/google/benchmark/blob/v1.1.0/src/cycleclock.h#L116
+                long long int virtual_timer_value;
+                asm volatile("mrs %0, cntvct_el0" : "=r"(virtual_timer_value));
+                return virtual_timer_value;
+        #else
+                #error unsupported hardware architecture
+        #endif
+}
+#if defined( __i386 ) || defined( __x86_64 )
+        #define Pause() __asm__ __volatile__ ( "pause" : : : )
+#elif defined( __ARM_ARCH )
+        #define Pause() __asm__ __volatile__ ( "YIELD" : : : )
+#else
+        #error unsupported architecture
+#endif
 static inline void affinity(int tid) {
 …
+}
+// Barrier from
+class barrier_t {
+public:
+        barrier_t(size_t total)
+                : waiting(0)
+                , total(total)
+        {}
+        void wait(unsigned) {
+                size_t target = waiting++;
+                target = (target - (target % total)) + total;
+                while(waiting < target)
+                        Pause();
+                assert(waiting < (1ul << 60));
+        }
+private:
+        std::atomic<size_t> waiting;
+        size_t total;
+};
 struct spinlock_t {
         std::atomic_bool ll = { false };
 …
                 while( __builtin_expect(ll.exchange(true),false) ) {
                         while(ll.load(std::memory_order_relaxed))
                                 asm volatile("pause");
+                                Pause();
+                }
+        }

doc/theses/thierry_delisle_PhD/code/readyQ_proto/work_stealing.hpp

-              rfeacef9
+              r5407cdc
 #include <memory>
 #include <mutex>
+#include <thread>
 #include <type_traits>
 …
 #include "utils.hpp"
 #include "links.hpp"
+#include "links2.hpp"
 #include "snzi.hpp"
+// #include <x86intrin.h>
 using namespace std;
+static const long long lim = 2000;
+static const unsigned nqueues = 2;
+struct __attribute__((aligned(128))) timestamp_t {
+        volatile unsigned long long val = 0;
+};
+template<typename node_t>
+struct __attribute__((aligned(128))) localQ_t {
+        #ifdef NO_MPSC
+                intrusive_queue_t<node_t> list;
+                inline auto ts() { return list.ts(); }
+                inline auto lock() { return list.lock.lock(); }
+                inline auto try_lock() { return list.lock.try_lock(); }
+                inline auto unlock() { return list.lock.unlock(); }
+                inline auto push( node_t * node ) { return list.push( node ); }
+                inline auto pop() { return list.pop(); }
+        #else
+                mpsc_queue<node_t> queue = {};
+                spinlock_t _lock = {};
+                inline auto ts() { auto h = queue.head(); return h ? h->_links.ts : 0ull; }
+                inline auto lock() { return _lock.lock(); }
+                inline auto try_lock() { return _lock.try_lock(); }
+                inline auto unlock() { return _lock.unlock(); }
+                inline auto push( node_t * node ) { return queue.push( node ); }
+                inline auto pop() { return queue.pop(); }
+        #endif
+};
 template<typename node_t>
 …
         work_stealing(unsigned _numThreads, unsigned)
+                : numThreads(_numThreads)
+                , lists(new intrusive_queue_t<node_t>[numThreads])
+                , snzi( std::log2( numThreads / 2 ), 2 )
+                : numThreads(_numThreads * nqueues)
+                , lists(new localQ_t<node_t>[numThreads])
+                // , lists(new intrusive_queue_t<node_t>[numThreads])
+                , times(new timestamp_t[numThreads])
+                // , snzi( std::log2( numThreads / 2 ), 2 )
+        {
 …
         __attribute__((noinline, hot)) void push(node_t * node) {
                 node->_links.ts = rdtscl();
+                if( node->_links.hint > numThreads ) {
+                        node->_links.hint = tls.rng.next() % numThreads;
+                        tls.stat.push.nhint++;
+                // node->_links.ts = 1;
+                auto & list = *({
+                        unsigned i;
+                        #ifdef NO_MPSC
+                                do {
+                        #endif
+                                tls.stats.push.attempt++;
+                                // unsigned r = tls.rng1.next();
+                                unsigned r = tls.it++;
+                                if(tls.my_queue == outside) {
+                                        i = r % numThreads;
+                                } else {
+                                        i = tls.my_queue + (r % nqueues);
+                                }
+                        #ifdef NO_MPSC
+                                } while(!lists[i].try_lock());
+                        #endif
+                        &lists[i];
+                });
+                list.push( node );
+                #ifdef NO_MPSC
+                        list.unlock();
+                #endif
+                // tls.rng2.set_raw_state( tls.rng1.get_raw_state());
+                // count++;
+                tls.stats.push.success++;
+        }
+        __attribute__((noinline, hot)) node_t * pop() {
+                if(tls.my_queue != outside) {
+                        // if( tls.myfriend == outside ) {
+                        //      auto r  = tls.rng1.next();
+                        //      tls.myfriend = r % numThreads;
+                        //      // assert(lists[(tls.it % nqueues) + tls.my_queue].ts() >= lists[((tls.it + 1) % nqueues) + tls.my_queue].ts());
+                        //      tls.mytime = std::min(lists[(tls.it % nqueues) + tls.my_queue].ts(), lists[((tls.it + 1) % nqueues) + tls.my_queue].ts());
+                        //      // times[tls.myfriend].val = 0;
+                        //      // lists[tls.myfriend].val = 0;
+                        // }
+                        // // else if(times[tls.myfriend].val == 0) {
+                        // // else if(lists[tls.myfriend].val == 0) {
+                        // else if(times[tls.myfriend].val < tls.mytime) {
+                        // // else if(times[tls.myfriend].val < lists[(tls.it % nqueues) + tls.my_queue].ts()) {
+                        //      node_t * n = try_pop(tls.myfriend, tls.stats.pop.help);
+                        //      tls.stats.help++;
+                        //      tls.myfriend = outside;
+                        //      if(n) return n;
+                        // }
+                        // if( tls.myfriend == outside ) {
+                        //      auto r  = tls.rng1.next();
+                        //      tls.myfriend = r % numThreads;
+                        //      tls.mytime = lists[((tls.it + 1) % nqueues) + tls.my_queue].ts();
+                        // }
+                        // else {
+                        //      if(times[tls.myfriend].val + 1000 < tls.mytime) {
+                        //              node_t * n = try_pop(tls.myfriend, tls.stats.pop.help);
+                        //              tls.stats.help++;
+                        //              if(n) return n;
+                        //      }
+                        //      tls.myfriend = outside;
+                        // }
+                        node_t * n = local();
+                        if(n) return n;
+                }
+                unsigned i = node->_links.hint;
+                auto & list = lists[i];
+                list.lock.lock();
+                if(list.push( node )) {
+                        snzi.arrive(i);
+                // try steal
+                for(int i = 0; i < 25; i++) {
+                        node_t * n = steal();
+                        if(n) return n;
+                }
+                list.lock.unlock();
+        }
+        __attribute__((noinline, hot)) node_t * pop() {
+                node_t * node;
+                while(true) {
+                        if(!snzi.query()) {
+                                return nullptr;
+                        }
+                        {
+                                unsigned i = tls.my_queue;
+                                auto & list = lists[i];
+                                if( list.ts() != 0 ) {
+                                        list.lock.lock();
+                                        if((node = try_pop(i))) {
+                                                tls.stat.pop.local.success++;
+                                                break;
+                                        }
+                                        else {
+                                                tls.stat.pop.local.elock++;
+                                        }
+                                }
+                                else {
+                                        tls.stat.pop.local.espec++;
+                                }
+                        }
+                        tls.stat.pop.steal.tried++;
+                        int i = tls.rng.next() % numThreads;
+                        auto & list = lists[i];
+                        if( list.ts() == 0 ) {
+                                tls.stat.pop.steal.empty++;
+                                continue;
+                        }
+                        if( !list.lock.try_lock() ) {
+                                tls.stat.pop.steal.locked++;
+                                continue;
+                        }
+                        if((node = try_pop(i))) {
+                                tls.stat.pop.steal.success++;
+                                break;
+                return search();
+        }
+private:
+        inline node_t * local() {
+                unsigned i = (--tls.it % nqueues) + tls.my_queue;
+                node_t * n = try_pop(i, tls.stats.pop.local);
+                if(n) return n;
+                i = (--tls.it % nqueues) + tls.my_queue;
+                return try_pop(i, tls.stats.pop.local);
+        }
+        inline node_t * steal() {
+                unsigned i = tls.rng2.prev() % numThreads;
+                return try_pop(i, tls.stats.pop.steal);
+        }
+        inline node_t * search() {
+                unsigned offset = tls.rng2.prev();
+                for(unsigned i = 0; i < numThreads; i++) {
+                        unsigned idx = (offset + i) % numThreads;
+                        node_t * thrd = try_pop(idx, tls.stats.pop.search);
+                        if(thrd) {
+                                return thrd;
+                        }
+                }
+                #if defined(READ)
+                        const unsigned f = READ;
+                        if(0 == (tls.it % f)) {
+                                unsigned i = tls.it / f;
+                                lists[i % numThreads].ts();
+                        }
+                        // lists[tls.it].ts();
+                        tls.it++;
+                #endif
+                return node;
+        }
+private:
+        node_t * try_pop(unsigned i) {
+                return nullptr;
+        }
+private:
+        struct attempt_stat_t {
+                std::size_t attempt = { 0 };
+                std::size_t elock   = { 0 };
+                std::size_t eempty  = { 0 };
+                std::size_t espec   = { 0 };
+                std::size_t success = { 0 };
+        };
+        node_t * try_pop(unsigned i, attempt_stat_t & stat) {
+                assert(i < numThreads);
                 auto & list = lists[i];
+                stat.attempt++;
+                // If the list is empty, don't try
+                if(list.ts() == 0) { stat.espec++; return nullptr; }
+                // If we can't get the lock, move on
+                if( !list.try_lock() ) { stat.elock++; return nullptr; }
                 // If list is empty, unlock and retry
                 if( list.ts() == 0 ) {
+                        list.lock.unlock();
+                        list.unlock();
+                        stat.eempty++;
                         return nullptr;
+                }
+                        // Actually pop the list
+                node_t * node;
+                bool emptied;
+                std::tie(node, emptied) = list.pop();
+                assert(node);
+                if(emptied) {
+                        snzi.depart(i);
+                }
+                // Unlock and return
+                list.lock.unlock();
+                return node;
+                auto node = list.pop();
+                list.unlock();
+                stat.success++;
+                #ifdef NO_MPSC
+                        // times[i].val = 1;
+                        times[i].val = node.first->_links.ts;
+                        // lists[i].val = node.first->_links.ts;
+                        return node.first;
+                #else
+                        times[i].val = node->_links.ts;
+                        return node;
+                #endif
+        }
 …
         static std::atomic_uint32_t ticket;
+        static const unsigned outside = 0xFFFFFFFF;
+        static inline unsigned calc_preferred() {
+                unsigned t = ticket++;
+                if(t == 0) return outside;
+                unsigned i = (t - 1) * nqueues;
+                return i;
+        }
         static __attribute__((aligned(128))) thread_local struct TLS {
+                Random     rng = { int(rdtscl()) };
+                unsigned   my_queue = ticket++;
+                Random     rng1 = { unsigned(std::hash<std::thread::id>{}(std::this_thread::get_id()) ^ rdtscl()) };
+                Random     rng2 = { unsigned(std::hash<std::thread::id>{}(std::this_thread::get_id()) ^ rdtscl()) };
+                unsigned   it   = 0;
+                unsigned   my_queue = calc_preferred();
+                unsigned   myfriend = outside;
+                unsigned long long int mytime = 0;
                 #if defined(READ)
                         unsigned it = 0;
 …
                 struct {
                         struct {
+                                std::size_t nhint = { 0 };
+                                std::size_t attempt = { 0 };
+                                std::size_t success = { 0 };
                         } push;
                         struct {
+                                struct {
+                                        std::size_t success = { 0 };
+                                        std::size_t espec = { 0 };
+                                        std::size_t elock = { 0 };
+                                } local;
+                                struct {
+                                        std::size_t tried   = { 0 };
+                                        std::size_t locked  = { 0 };
+                                        std::size_t empty   = { 0 };
+                                        std::size_t success = { 0 };
+                                } steal;
+                                attempt_stat_t help;
+                                attempt_stat_t local;
+                                attempt_stat_t steal;
+                                attempt_stat_t search;
                         } pop;
+                } stat;
+                        std::size_t help = { 0 };
+                } stats;
         } tls;
 private:
         const unsigned numThreads;
+        std::unique_ptr<intrusive_queue_t<node_t> []> lists;
+        __attribute__((aligned(64))) snzi_t snzi;
+        std::unique_ptr<localQ_t<node_t> []> lists;
+        // std::unique_ptr<intrusive_queue_t<node_t> []> lists;
+        std::unique_ptr<timestamp_t []> times;
+        __attribute__((aligned(128))) std::atomic_size_t count;
 #ifndef NO_STATS
 …
         static struct GlobalStats {
                 struct {
+                        std::atomic_size_t nhint = { 0 };
+                        std::atomic_size_t attempt = { 0 };
+                        std::atomic_size_t success = { 0 };
                 } push;
                 struct {
                         struct {
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t elock   = { 0 };
+                                std::atomic_size_t eempty  = { 0 };
+                                std::atomic_size_t espec   = { 0 };
                                 std::atomic_size_t success = { 0 };
+                                std::atomic_size_t espec = { 0 };
+                                std::atomic_size_t elock = { 0 };
+                        } help;
+                        struct {
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t elock   = { 0 };
+                                std::atomic_size_t eempty  = { 0 };
+                                std::atomic_size_t espec   = { 0 };
+                                std::atomic_size_t success = { 0 };
                         } local;
                         struct {
+                                std::atomic_size_t tried   = { 0 };
+                                std::atomic_size_t locked  = { 0 };
+                                std::atomic_size_t empty   = { 0 };
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t elock   = { 0 };
+                                std::atomic_size_t eempty  = { 0 };
+                                std::atomic_size_t espec   = { 0 };
                                 std::atomic_size_t success = { 0 };
                         } steal;
+                        struct {
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t elock   = { 0 };
+                                std::atomic_size_t eempty  = { 0 };
+                                std::atomic_size_t espec   = { 0 };
+                                std::atomic_size_t success = { 0 };
+                        } search;
                 } pop;
+                std::atomic_size_t help = { 0 };
         } global_stats;
 public:
         static void stats_tls_tally() {
+                global_stats.push.nhint += tls.stat.push.nhint;
+                global_stats.pop.local.success += tls.stat.pop.local.success;
+                global_stats.pop.local.espec   += tls.stat.pop.local.espec  ;
+                global_stats.pop.local.elock   += tls.stat.pop.local.elock  ;
+                global_stats.pop.steal.tried   += tls.stat.pop.steal.tried  ;
+                global_stats.pop.steal.locked  += tls.stat.pop.steal.locked ;
+                global_stats.pop.steal.empty   += tls.stat.pop.steal.empty  ;
+                global_stats.pop.steal.success += tls.stat.pop.steal.success;
+        }
+        static void stats_print(std::ostream & os ) {
+                global_stats.push.attempt += tls.stats.push.attempt;
+                global_stats.push.success += tls.stats.push.success;
+                global_stats.pop.help  .attempt += tls.stats.pop.help  .attempt;
+                global_stats.pop.help  .elock   += tls.stats.pop.help  .elock  ;
+                global_stats.pop.help  .eempty  += tls.stats.pop.help  .eempty ;
+                global_stats.pop.help  .espec   += tls.stats.pop.help  .espec  ;
+                global_stats.pop.help  .success += tls.stats.pop.help  .success;
+                global_stats.pop.local .attempt += tls.stats.pop.local .attempt;
+                global_stats.pop.local .elock   += tls.stats.pop.local .elock  ;
+                global_stats.pop.local .eempty  += tls.stats.pop.local .eempty ;
+                global_stats.pop.local .espec   += tls.stats.pop.local .espec  ;
+                global_stats.pop.local .success += tls.stats.pop.local .success;
+                global_stats.pop.steal .attempt += tls.stats.pop.steal .attempt;
+                global_stats.pop.steal .elock   += tls.stats.pop.steal .elock  ;
+                global_stats.pop.steal .eempty  += tls.stats.pop.steal .eempty ;
+                global_stats.pop.steal .espec   += tls.stats.pop.steal .espec  ;
+                global_stats.pop.steal .success += tls.stats.pop.steal .success;
+                global_stats.pop.search.attempt += tls.stats.pop.search.attempt;
+                global_stats.pop.search.elock   += tls.stats.pop.search.elock  ;
+                global_stats.pop.search.eempty  += tls.stats.pop.search.eempty ;
+                global_stats.pop.search.espec   += tls.stats.pop.search.espec  ;
+                global_stats.pop.search.success += tls.stats.pop.search.success;
+                global_stats.help += tls.stats.help;
+        }
+        static void stats_print(std::ostream & os, double duration ) {
                 std::cout << "----- Work Stealing Stats -----" << std::endl;
+                double stealSucc = double(global_stats.pop.steal.success) / global_stats.pop.steal.tried;
+                os << "Push to new Q : " << std::setw(15) << global_stats.push.nhint << "\n";
+                os << "Local Pop     : " << std::setw(15) << global_stats.pop.local.success << "\n";
+                os << "Steal Pop     : " << std::setw(15) << global_stats.pop.steal.success << "(" << global_stats.pop.local.espec << "s, " << global_stats.pop.local.elock << "l)\n";
+                os << "Steal Success : " << std::setw(15) << stealSucc << "(" << global_stats.pop.steal.tried << " tries)\n";
+                os << "Steal Fails   : " << std::setw(15) << global_stats.pop.steal.empty << "e, " << global_stats.pop.steal.locked << "l\n";
+                double push_suc = (100.0 * double(global_stats.push.success) / global_stats.push.attempt);
+                double push_len = double(global_stats.push.attempt     ) / global_stats.push.success;
+                os << "Push   Pick : " << push_suc << " %, len " << push_len << " (" << global_stats.push.attempt      << " / " << global_stats.push.success << ")\n";
+                double hlp_suc = (100.0 * double(global_stats.pop.help.success) / global_stats.pop.help.attempt);
+                double hlp_len = double(global_stats.pop.help.attempt     ) / global_stats.pop.help.success;
+                os << "Help        : " << hlp_suc << " %, len " << hlp_len << " (" << global_stats.pop.help.attempt      << " / " << global_stats.pop.help.success << ")\n";
+                os << "Help Fail   : " << global_stats.pop.help.espec << "s, " << global_stats.pop.help.eempty << "e, " << global_stats.pop.help.elock << "l\n";
+                double pop_suc = (100.0 * double(global_stats.pop.local.success) / global_stats.pop.local.attempt);
+                double pop_len = double(global_stats.pop.local.attempt     ) / global_stats.pop.local.success;
+                os << "Local       : " << pop_suc << " %, len " << pop_len << " (" << global_stats.pop.local.attempt      << " / " << global_stats.pop.local.success << ")\n";
+                os << "Local Fail  : " << global_stats.pop.local.espec << "s, " << global_stats.pop.local.eempty << "e, " << global_stats.pop.local.elock << "l\n";
+                double stl_suc = (100.0 * double(global_stats.pop.steal.success) / global_stats.pop.steal.attempt);
+                double stl_len = double(global_stats.pop.steal.attempt     ) / global_stats.pop.steal.success;
+                os << "Steal       : " << stl_suc << " %, len " << stl_len << " (" << global_stats.pop.steal.attempt      << " / " << global_stats.pop.steal.success << ")\n";
+                os << "Steal Fail  : " << global_stats.pop.steal.espec << "s, " << global_stats.pop.steal.eempty << "e, " << global_stats.pop.steal.elock << "l\n";
+                double srh_suc = (100.0 * double(global_stats.pop.search.success) / global_stats.pop.search.attempt);
+                double srh_len = double(global_stats.pop.search.attempt     ) / global_stats.pop.search.success;
+                os << "Search      : " << srh_suc << " %, len " << srh_len << " (" << global_stats.pop.search.attempt      << " / " << global_stats.pop.search.success << ")\n";
+                os << "Search Fail : " << global_stats.pop.search.espec << "s, " << global_stats.pop.search.eempty << "e, " << global_stats.pop.search.elock << "l\n";
+                os << "Helps       : " << std::setw(15) << std::scientific << global_stats.help / duration << "/sec (" << global_stats.help  << ")\n";
+        }
 private:

doc/user/figures/Cdecl.fig

-              rfeacef9
+              r5407cdc
 #FIG 3.2  Produced by xfig version 3.2.5b
+#FIG 3.2  Produced by xfig version 3.2.7b
 Landscape
 Center
 Inches
 Letter
+Letter
 .00
 Single
 …
 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5
 1200 3600 1200 3600 1350 2850 1350 2850 1200
 1 0 50 -1 4 11 0.0000 2 120 90 2925 1325 0\001
 1 0 50 -1 4 11 0.0000 2 120 90 3075 1325 1\001
 1 0 50 -1 4 11 0.0000 2 120 90 3225 1325 2\001
 1 0 50 -1 4 11 0.0000 2 120 90 3375 1325 3\001
 1 0 50 -1 4 11 0.0000 2 120 90 3525 1325 4\001
+1 0 50 -1 4 11 0.0000 2 120 105 3075 1335 1\001
+1 0 50 -1 4 11 0.0000 2 120 105 3225 1335 2\001
+1 0 50 -1 4 11 0.0000 2 120 105 3375 1335 3\001
+1 0 50 -1 4 11 0.0000 2 120 105 3525 1335 4\001
+1 0 50 -1 4 11 0.0000 2 120 105 2925 1335 0\001
 -6
 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5
 …
 1 1.00 45.00 60.00
 1275 2850 1275
 1 0 50 -1 4 11 0.0000 2 120 90 1350 1650 0\001
 1 0 50 -1 4 11 0.0000 2 120 90 1500 1650 1\001
 1 0 50 -1 4 11 0.0000 2 120 90 1650 1650 2\001
 1 0 50 -1 4 11 0.0000 2 120 90 1800 1650 3\001
 1 0 50 -1 4 11 0.0000 2 120 90 1950 1650 4\001
+1 0 50 -1 4 11 0.0000 2 120 105 1350 1650 0\001
+1 0 50 -1 4 11 0.0000 2 120 105 1500 1650 1\001
+1 0 50 -1 4 11 0.0000 2 120 105 1650 1650 2\001
+1 0 50 -1 4 11 0.0000 2 120 105 1800 1650 3\001
+1 0 50 -1 4 11 0.0000 2 120 105 1950 1650 4\001
 1 0 50 -1 4 11 0.0000 2 90 90 1200 1325 x\001
 1 0 50 -1 4 11 0.0000 2 90 90 2400 1325 x\001

doc/user/user.tex

-              rfeacef9
+              r5407cdc
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Mon Feb 15 13:48:53 2021
 %% Update Count     : 4452
+%% Last Modified On : Sun Apr 25 19:03:03 2021
+%% Update Count     : 4951
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 % math escape $...$ (dollar symbol)
 \input{common}                                          % common CFA document macros
+\setlength{\gcolumnposn}{3in}
 \CFAStyle                                                                                               % use default CFA format-style
 \lstset{language=CFA}                                                                   % CFA default lnaguage
 \lstnewenvironment{C++}[1][]                            % use C++ style
 {\lstset{language=C++,moredelim=**[is][\protect\color{red}]{@}{@},#1}}
+{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®},#1}}
 {}
 …
 \newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
 \newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}}
 \newcommand{\R}[1]{\Textbf{#1}}
 \newcommand{\RC}[1]{\Textbf{\LstBasicStyle{#1}}}
+\newcommand{\R}[1]{{\color{red}#1}}
+\newcommand{\RB}[1]{\Textbf{#1}}
 \newcommand{\B}[1]{{\Textbf[blue]{#1}}}
 \newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}}
 …
 int main( void ) {
         int x = 0, y = 1, z = 2;
         @printf( "%d %d %d\n", x, y, z );@
+        ®printf( "%d %d %d\n", x, y, z );®
+}
 \end{cfa}
 …
 int main( void ) {
         int x = 0, y = 1, z = 2;
         @sout | x | y | z;@$\indexc{sout}$
+        ®sout | x | y | z;®$\indexc{sout}$
+}
 \end{cfa}
 …
 int main() {
         int x = 0, y = 1, z = 2;
         @cout<<x<<" "<<y<<" "<<z<<endl;@
+        ®cout<<x<<" "<<y<<" "<<z<<endl;®
+}
 \end{cfa}
 …
 \begin{tabular}{@{}rcccccccc@{}}
                 & 2021  & 2016  & 2011  & 2006  & 2001  & 1996  & 1991  & 1986  \\ \hline
 \R{C}   & \R{1} & \R{2} & \R{2} & \R{1} & \R{1} & \R{1} & \R{1} & \R{1} \\
+\RB{C}  & \RB{1}& \RB{2}& \RB{2}& \RB{1}& \RB{1}& \RB{1}& \RB{1}& \RB{1}\\
 Java    & 2             & 1             & 1             & 2             & 3             & 28    & -             & -             \\
 Python  & 3             & 5             & 6             & 7             & 23    & 13    & -             & -             \\
 …
 The signature feature of \CFA is \emph{\Index{overload}able} \Index{parametric-polymorphic} functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name):
 \begin{cfa}
 @forall( otype T )@ T identity( T val ) { return val; }
+®forall( otype T )® T identity( T val ) { return val; }
 int forty_two = identity( 42 ); $\C{// T is bound to int, forty\_two == 42}$
 \end{cfa}
 …
 Whereas, \CFA wraps each of these routines into one overloaded name ©abs©:
 \begin{cfa}
 char @abs@( char );
 extern "C" { int @abs@( int ); } $\C{// use default C routine for int}$
 long int @abs@( long int );
 long long int @abs@( long long int );
 float @abs@( float );
 double @abs@( double );
 long double @abs@( long double );
 float _Complex @abs@( float _Complex );
 double _Complex @abs@( double _Complex );
 long double _Complex @abs@( long double _Complex );
+char ®abs®( char );
+extern "C" { int ®abs®( int ); } $\C{// use default C routine for int}$
+long int ®abs®( long int );
+long long int ®abs®( long long int );
+float ®abs®( float );
+double ®abs®( double );
+long double ®abs®( long double );
+float _Complex ®abs®( float _Complex );
+double _Complex ®abs®( double _Complex );
+long double _Complex ®abs®( long double _Complex );
 \end{cfa}
 The problem is \Index{name clash} between the C name ©abs© and the \CFA names ©abs©, resulting in two name linkages\index{C linkage}: ©extern "C"© and ©extern "Cforall"© (default).
 …
 The 2011 C standard plus GNU extensions.
 \item
 \Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]$-fgnu89-inline$}}
+\Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]{-fgnu89-inline}}}
 Use the traditional GNU semantics for inline routines in C11 mode, which allows inline routines in header files.
 \end{description}
 …
 Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
 \begin{cfa}
 int @``@otype = 3; $\C{// make keyword an identifier}$
 double @``@forall = 3.5;
+int ®``®otype = 3; $\C{// make keyword an identifier}$
+double ®``®forall = 3.5;
 \end{cfa}
 …
 // include file uses the CFA keyword "with".
 #if ! defined( with )                                                   $\C{// nesting ?}$
 #define with @``@with                                                   $\C{// make keyword an identifier}$
+#define with ®``®with                                                   $\C{// make keyword an identifier}$
 #define __CFA_BFD_H__
 #endif
 …
 Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore} as a separator, \eg:
 \begin{cfa}
 @_@147@_@483@_@648; $\C{// decimal constant}$
 @_@ul; $\C{// decimal unsigned long constant}$
 @_@377; $\C{// octal constant}$
 x@_@ff@_@ff; $\C{// hexadecimal constant}$
 x@_@ef3d@_@aa5c; $\C{// hexadecimal constant}$
 .141@_@592@_@654; $\C{// floating constant}$
 @_@e@_@+1@_@00; $\C{// floating constant}$
 x@_@ff@_@ff@_@p@_@3; $\C{// hexadecimal floating}$
 x@_@1.ffff@_@ffff@_@p@_@128@_@l; $\C{// hexadecimal floating long constant}$
 L@_@$"\texttt{\textbackslash{x}}$@_@$\texttt{ff}$@_@$\texttt{ee}"$; $\C{// wide character constant}$
+®_®147®_®483®_®648; $\C{// decimal constant}$
+®_®ul; $\C{// decimal unsigned long constant}$
+®_®377; $\C{// octal constant}$
+x®_®ff®_®ff; $\C{// hexadecimal constant}$
+x®_®ef3d®_®aa5c; $\C{// hexadecimal constant}$
+.141®_®592®_®654; $\C{// floating constant}$
+®_®e®_®+1®_®00; $\C{// floating constant}$
+x®_®ff®_®ff®_®p®_®3; $\C{// hexadecimal floating}$
+x®_®1.ffff®_®ffff®_®p®_®128®_®l; $\C{// hexadecimal floating long constant}$
+L®_®$"\texttt{\textbackslash{x}}$®_®$\texttt{ff}$®_®$\texttt{ee}"$; $\C{// wide character constant}$
 \end{cfa}
 The rules for placement of underscores are:
 …
 Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative.
 \begin{cfa}
 sout | 1 @\@ 0 | 1 @\@ 1 | 2 @\@ 8 | -4 @\@ 3 | 5 @\@ 3 | 5 @\@ 32 | 5L @\@ 32 | 5L @\@ 64 | -4 @\@ -3 | -4.0 @\@ -3 | 4.0 @\@ 2.1
            | (1.0f+2.0fi) @\@ (3.0f+2.0fi);
 1 256 -64 125 @0@ 3273344365508751233 @0@ @0@ -0.015625 18.3791736799526 0.264715-1.1922i
+sout | 1 ®\® 0 | 1 ®\® 1 | 2 ®\® 8 | -4 ®\® 3 | 5 ®\® 3 | 5 ®\® 32 | 5L ®\® 32 | 5L ®\® 64 | -4 ®\® -3 | -4.0 ®\® -3 | 4.0 ®\® 2.1
+           | (1.0f+2.0fi) ®\® (3.0f+2.0fi);
+1 256 -64 125 ®0® 3273344365508751233 ®0® ®0® -0.015625 18.3791736799526 0.264715-1.1922i
 \end{cfa}
 Note, ©5 \ 32© and ©5L \ 64© overflow, and ©-4 \ -3© is a fraction but stored in an integer so all three computations generate an integral zero.
 …
 \begin{cfa}
 forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
 T ?@\@?( T ep, unsigned int y );
+T ?®\®?( T ep, unsigned int y );
 forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
 T ?@\@?( T ep, unsigned long int y );
+T ?®\®?( T ep, unsigned long int y );
 \end{cfa}
 The user type ©T© must define multiplication, one (©1©), and ©*©.
 …
 %\subsection{\texorpdfstring{\protect\lstinline@if@/\protect\lstinline@while@ Statement}{if Statement}}
+%\subsection{\texorpdfstring{\protect\lstinline{if}/\protect\lstinline{while} Statement}{if Statement}}
 \subsection{\texorpdfstring{\LstKeywordStyle{if} / \LstKeywordStyle{while} Statement}{if / while Statement}}
 …
 Declarations in the ©do©-©while© condition are not useful because they appear after the loop body.}
 \begin{cfa}
 if ( @int x = f()@ ) ... $\C{// x != 0}$
 if ( @int x = f(), y = g()@ ) ... $\C{// x != 0 \&\& y != 0}$
 if ( @int x = f(), y = g(); x < y@ ) ... $\C{// relational expression}$
 if ( @struct S { int i; } x = { f() }; x.i < 4@ ) $\C{// relational expression}$
 while ( @int x = f()@ ) ... $\C{// x != 0}$
 while ( @int x = f(), y = g()@ ) ... $\C{// x != 0 \&\& y != 0}$
 while ( @int x = f(), y = g(); x < y@ ) ... $\C{// relational expression}$
 while ( @struct S { int i; } x = { f() }; x.i < 4@ ) ... $\C{// relational expression}$
+if ( ®int x = f()® ) ... $\C{// x != 0}$
+if ( ®int x = f(), y = g()® ) ... $\C{// x != 0 \&\& y != 0}$
+if ( ®int x = f(), y = g(); x < y® ) ... $\C{// relational expression}$
+if ( ®struct S { int i; } x = { f() }; x.i < 4® ) $\C{// relational expression}$
+while ( ®int x = f()® ) ... $\C{// x != 0}$
+while ( ®int x = f(), y = g()® ) ... $\C{// x != 0 \&\& y != 0}$
+while ( ®int x = f(), y = g(); x < y® ) ... $\C{// relational expression}$
+while ( ®struct S { int i; } x = { f() }; x.i < 4® ) ... $\C{// relational expression}$
 \end{cfa}
 Unless a relational expression is specified, each variable is compared not equal to 0, which is the standard semantics for the ©if©/©while© expression, and the results are combined using the logical ©&&© operator.
 …
 %\section{\texorpdfstring{\protect\lstinline@case@ Clause}{case Clause}}
+%\section{\texorpdfstring{\protect\lstinline{case} Clause}{case Clause}}
 \subsection{\texorpdfstring{\LstKeywordStyle{case} Clause}{case Clause}}
 \label{s:caseClause}
 …
 \begin{cfa}
 switch ( i ) {
   case @1, 3, 5@:
+  case ®1, 3, 5®:
         ...
   case @2, 4, 6@:
+  case ®2, 4, 6®:
         ...
+}
 …
 \end{cquote}
 In addition, subranges are allowed to specify case values.\footnote{
 gcc has the same mechanism but awkward syntax, \lstinline@2 ...42@, because a space is required after a number, otherwise the period is a decimal point.}
+gcc has the same mechanism but awkward syntax, \lstinline{2 ...42}, because a space is required after a number, otherwise the period is a decimal point.}
 \begin{cfa}
 switch ( i ) {
   case @1~5:@ $\C{// 1, 2, 3, 4, 5}$
+  case ®1~5:® $\C{// 1, 2, 3, 4, 5}$
         ...
   case @10~15:@ $\C{// 10, 11, 12, 13, 14, 15}$
+  case ®10~15:® $\C{// 10, 11, 12, 13, 14, 15}$
         ...
+}
 …
 Lists of subranges are also allowed.
 \begin{cfa}
 case @1~5, 12~21, 35~42@:
 \end{cfa}
 %\section{\texorpdfstring{\protect\lstinline@switch@ Statement}{switch Statement}}
+case ®1~5, 12~21, 35~42®:
+\end{cfa}
+%\section{\texorpdfstring{\protect\lstinline{switch} Statement}{switch Statement}}
 \subsection{\texorpdfstring{\LstKeywordStyle{switch} Statement}{switch Statement}}
 …
 if ( argc == 3 ) {
         // open output file
         @// open input file
 @} else if ( argc == 2 ) {
         @// open input file (duplicate)
 @} else {
+        ®// open input file
+®} else if ( argc == 2 ) {
+        ®// open input file (duplicate)
+®} else {
         // usage message
+}
 …
 \begin{cfa}
 switch ( i ) {
   @case 1: case 3: case 5:@     // odd values
+  ®case 1: case 3: case 5:®     // odd values
         // odd action
         break;
   @case 2: case 4: case 6:@     // even values
+  ®case 2: case 4: case 6:®     // even values
         // even action
         break;
 …
         if ( j < k ) {
                 ...
           @case 1:@             // transfer into "if" statement
+          ®case 1:®             // transfer into "if" statement
                 ...
         } // if
 …
         while ( j < 5 ) {
                 ...
           @case 3:@             // transfer into "while" statement
+          ®case 3:®             // transfer into "while" statement
                 ...
         } // while
 …
 \begin{cfa}
 switch ( x ) {
         @int y = 1;@ $\C{// unreachable initialization}$
         @x = 7;@ $\C{// unreachable code without label/branch}$
+        ®int y = 1;® $\C{// unreachable initialization}$
+        ®x = 7;® $\C{// unreachable code without label/branch}$
   case 0: ...
         ...
         @int z = 0;@ $\C{// unreachable initialization, cannot appear after case}$
+        ®int z = 0;® $\C{// unreachable initialization, cannot appear after case}$
         z = 2;
   case 1:
         @x = z;@ $\C{// without fall through, z is uninitialized}$
+        ®x = z;® $\C{// without fall through, z is uninitialized}$
+}
 \end{cfa}
 …
 Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no implicit fall-through semantics and an explicit fall-through if the last statement of a case-clause ends with the new keyword ©fallthrough©/©fallthru©, \eg:
 \begin{cfa}
 @choose@ ( i ) {
+®choose® ( i ) {
   case 1:  case 2:  case 3:
         ...
         @// implicit end of switch (break)
   @case 5:
+        ®// implicit end of switch (break)
+  ®case 5:
         ...
         @fallthru@; $\C{// explicit fall through}$
+        ®fallthru®; $\C{// explicit fall through}$
   case 7:
         ...
         @break@ $\C{// explicit end of switch (redundant)}$
+        ®break® $\C{// explicit end of switch (redundant)}$
   default:
         j = 3;
 …
 \begin{cfa}
 switch ( x ) {
         @int i = 0;@ $\C{// allowed only at start}$
+        ®int i = 0;® $\C{// allowed only at start}$
   case 0:
         ...
         @int j = 0;@ $\C{// disallowed}$
+        ®int j = 0;® $\C{// disallowed}$
   case 1:
+        {
                 @int k = 0;@ $\C{// allowed at different nesting levels}$
+                ®int k = 0;® $\C{// allowed at different nesting levels}$
                 ...
           @case 2:@ $\C{// disallow case in nested statements}$
+          ®case 2:® $\C{// disallow case in nested statements}$
+        }
   ...
 …
   case 3:
         if ( ... ) {
                 ... @fallthru;@ // goto case 4
+                ... ®fallthru;® // goto case 4
         } else {
                 ...
 …
 choose ( ... ) {
   case 3:
         ... @fallthrough common;@
+        ... ®fallthrough common;®
   case 4:
         ... @fallthrough common;@
   @common:@ // below fallthrough
+        ... ®fallthrough common;®
+  ®common:® // below fallthrough
                           // at case-clause level
         ...     // common code for cases 3/4
 …
                 for ( ... ) {
                         // multi-level transfer
                         ... @fallthru common;@
+                        ... ®fallthru common;®
+                }
                 ...
+        }
         ...
   @common:@ // below fallthrough
+  ®common:® // below fallthrough
                           // at case-clause level
 \end{cfa}
 …
 \hline
 \begin{cfa}
 while @($\,$)@ { sout | "empty"; break; }
 do { sout | "empty"; break; } while @($\,$)@;
 for @($\,$)@ { sout | "empty"; break; }
 for ( @0@ ) { sout | "A"; } sout | "zero";
 for ( @1@ ) { sout | "A"; }
 for ( @10@ ) { sout | "A"; }
 for ( @= 10@ ) { sout | "A"; }
 for ( @1 ~= 10 ~ 2@ ) { sout | "B"; }
 for ( @10 -~= 1 ~ 2@ ) { sout | "C"; }
 for ( @0.5 ~ 5.5@ ) { sout | "D"; }
 for ( @5.5 -~ 0.5@ ) { sout | "E"; }
 for ( @i; 10@ ) { sout | i; }
 for ( @i; = 10@ ) { sout | i; }
 for ( @i; 1 ~= 10 ~ 2@ ) { sout | i; }
 for ( @i; 10 -~= 1 ~ 2@ ) { sout | i; }
 for ( @i; 0.5 ~ 5.5@ ) { sout | i; }
 for ( @i; 5.5 -~ 0.5@ ) { sout | i; }
 for ( @ui; 2u ~= 10u ~ 2u@ ) { sout | ui; }
 for ( @ui; 10u -~= 2u ~ 2u@ ) { sout | ui; }
+while ®($\,$)® { sout | "empty"; break; }
+do { sout | "empty"; break; } while ®($\,$)®;
+for ®($\,$)® { sout | "empty"; break; }
+for ( ®0® ) { sout | "A"; } sout | "zero";
+for ( ®1® ) { sout | "A"; }
+for ( ®10® ) { sout | "A"; }
+for ( ®= 10® ) { sout | "A"; }
+for ( ®1 ~= 10 ~ 2® ) { sout | "B"; }
+for ( ®10 -~= 1 ~ 2® ) { sout | "C"; }
+for ( ®0.5 ~ 5.5® ) { sout | "D"; }
+for ( ®5.5 -~ 0.5® ) { sout | "E"; }
+for ( ®i; 10® ) { sout | i; }
+for ( ®i; = 10® ) { sout | i; }
+for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; }
+for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; }
+for ( ®i; 0.5 ~ 5.5® ) { sout | i; }
+for ( ®i; 5.5 -~ 0.5® ) { sout | i; }
+for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; }
+for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; }
 enum { N = 10 };
 for ( @N@ ) { sout | "N"; }
 for ( @i; N@ ) { sout | i; }
 for ( @i; N -~ 0@ ) { sout | i; }
+for ( ®N® ) { sout | "N"; }
+for ( ®i; N® ) { sout | i; }
+for ( ®i; N -~ 0® ) { sout | i; }
 const int start = 3, comp = 10, inc = 2;
 for ( @i; start ~ comp ~ inc + 1@ ) { sout | i; }
 for ( i; 1 ~ $\R{@}$ ) { if ( i > 10 ) break; sout | i; }
 for ( i; 10 -~ $\R{@}$ ) { if ( i < 0 ) break; sout | i; }
 for ( i; 2 ~ $\R{@}$ ~ 2 ) { if ( i > 10 ) break; sout | i; }
 for ( i; 2.1 ~ $\R{@}$ ~ $\R{@}$ ) { if ( i > 10.5 ) break; sout | i; i += 1.7; }
 for ( i; 10 -~ $\R{@}$ ~ 2 ) { if ( i < 0 ) break; sout | i; }
 for ( i; 12.1 ~ $\R{@}$ ~ $\R{@}$ ) { if ( i < 2.5 ) break; sout | i; i -= 1.7; }
 for ( i; 5 @:@ j; -5 ~ $@$ ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 -~ $@$ ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 ~ $@$ ~ 2 ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 ~ $@$ ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 -~ $@$ ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 ~ $@$ ~ 2 ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 @:@ k; 1.5 ~ $@$ ) { sout | i | j | k; }
 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 @:@ k; 1.5 ~ $@$ ) { sout | i | j | k; }
 for ( i; 5 @:@ k; 1.5 ~ $@$ @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j | k; }
+for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; }
+for ( i; 1 ~ ®@® ) { if ( i > 10 ) break; sout | i; }
+for ( i; 10 -~ ®@® ) { if ( i < 0 ) break; sout | i; }
+for ( i; 2 ~ ®@® ~ 2 ) { if ( i > 10 ) break; sout | i; }
+for ( i; 2.1 ~ ®@® ~ ®@® ) { if ( i > 10.5 ) break; sout | i; i += 1.7; }
+for ( i; 10 -~ ®@® ~ 2 ) { if ( i < 0 ) break; sout | i; }
+for ( i; 12.1 ~ ®@® ~ ®@® ) { if ( i < 2.5 ) break; sout | i; i -= 1.7; }
+for ( i; 5 ®:® j; -5 ~ @ ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 ~ @ ~ 2 ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ~ 2 ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 ~ @ ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 ~ @ ~ 2 ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ~ 2 ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ~ 2 ®:® k; 1.5 ~ @ ) { sout | i | j | k; }
+for ( i; 5 ®:® j; -5 -~ @ ~ 2 ®:® k; 1.5 ~ @ ) { sout | i | j | k; }
+for ( i; 5 ®:® k; 1.5 ~ @ ®:® j; -5 -~ @ ~ 2 ) { sout | i | j | k; }
 \end{cfa}
+&
 …
 The loop index is polymorphic in the type of the comparison value N (when the start value is implicit) or the start value M.
 \begin{cfa}
 for ( i; @5@ )                                  $\C[2.5in]{// typeof(5) i; 5 is comparison value}$
 for ( i; @1.5@~5.5~0.5 )                $\C{// typeof(1.5) i; 1.5 is start value}$
+for ( i; ®5® )                                  $\C[2.5in]{// typeof(5) i; 5 is comparison value}$
+for ( i; ®1.5®~5.5~0.5 )                $\C{// typeof(1.5) i; 1.5 is start value}$
 \end{cfa}
 \item
 An empty conditional implies comparison value of ©1© (true).
 \begin{cfa}
 while ( $\R{/*empty*/}$ )               $\C{// while ( true )}$
 for ( $\R{/*empty*/}$ )                 $\C{// for ( ; true; )}$
 do ... while ( $\R{/*empty*/}$ ) $\C{// do ... while ( true )}$
+while ( ®/*empty*/®  )                  $\C{// while ( true )}$
+for ( ®/*empty*/®  )                    $\C{// for ( ; true; )}$
+do ... while ( ®/*empty*/®  )    $\C{// do ... while ( true )}$
 \end{cfa}
 \item
 A comparison N is implicit up-to exclusive range [0,N\R{)}.
 \begin{cfa}
 for ( @5@ )                                             $\C{// for ( typeof(5) i; i < 5; i += 1 )}$
+for ( ®5® )                                             $\C{// for ( typeof(5) i; i < 5; i += 1 )}$
 \end{cfa}
 \item
 A comparison ©=© N is implicit up-to inclusive range [0,N\R{]}.
 \begin{cfa}
 for ( @=@5 )                                    $\C{// for ( typeof(5) i; i <= 5; i += 1 )}$
+for ( ®=®5 )                                    $\C{// for ( typeof(5) i; i <= 5; i += 1 )}$
 \end{cfa}
 \item
 The up-to range M ©~©\index{~@©~©} N means exclusive range [M,N\R{)}.
 \begin{cfa}
 for ( 1@~@5 )                                   $\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}$
+for ( 1®~®5 )                                   $\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}$
 \end{cfa}
 \item
 The up-to range M ©~=©\index{~=@©~=©} N means inclusive range [M,N\R{]}.
 \begin{cfa}
 for ( 1@~=@5 )                                  $\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}$
+for ( 1®~=®5 )                                  $\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}$
 \end{cfa}
 \item
 The down-to range M ©-~©\index{-~@©-~©} N means exclusive range [N,M\R{)}.
 \begin{cfa}
 for ( 1@-~@5 )                                  $\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}$
+for ( 1®-~®5 )                                  $\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}$
 \end{cfa}
 \item
 The down-to range M ©-~=©\index{-~=@©-~=©} N means inclusive range [N,M\R{]}.
 \begin{cfa}
 for ( 1@-~=@5 )                                 $\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}$
+for ( 1®-~=®5 )                                 $\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}$
 \end{cfa}
 \item
 ©@© means put nothing in this field.
 \begin{cfa}
 for ( 1~$\R{@}$~2 )                             $\C{// for ( typeof(1) i = 1; /*empty*/; i += 2 )}$
+for ( 1~®@®~2 )                                 $\C{// for ( typeof(1) i = 1; /*empty*/; i += 2 )}$
 \end{cfa}
 \item
 ©:© means start another index.
 \begin{cfa}
 for ( i; 5 @:@ j; 2~12~3 )              $\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}\CRT$
+for ( i; 5 ®:® j; 2~12~3 )              $\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}\CRT$
 \end{cfa}
 \end{itemize}
 %\subsection{\texorpdfstring{Labelled \protect\lstinline@continue@ / \protect\lstinline@break@}{Labelled continue / break}}
+%\subsection{\texorpdfstring{Labelled \protect\lstinline{continue} / \protect\lstinline{break}}{Labelled continue / break}}
 \subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}}
 …
 \begin{lrbox}{\myboxA}
 \begin{cfa}[tabsize=3]
 @Compound:@ {
         @Try:@ try {
                 @For:@ for ( ... ) {
                         @While:@ while ( ... ) {
                                 @Do:@ do {
                                         @If:@ if ( ... ) {
                                                 @Switch:@ switch ( ... ) {
+®Compound:® {
+        ®Try:® try {
+                ®For:® for ( ... ) {
+                        ®While:® while ( ... ) {
+                                ®Do:® do {
+                                        ®If:® if ( ... ) {
+                                                ®Switch:® switch ( ... ) {
                                                         case 3:
                                                                 @break Compound@;
                                                                 @break Try@;
                                                                 @break For@;      /* or */  @continue For@;
                                                                 @break While@;  /* or */  @continue While@;
                                                                 @break Do@;      /* or */  @continue Do@;
                                                                 @break If@;
                                                                 @break Switch@;
+                                                                ®break Compound®;
+                                                                ®break Try®;
+                                                                ®break For®;      /* or */  ®continue For®;
+                                                                ®break While®;  /* or */  ®continue While®;
+                                                                ®break Do®;      /* or */  ®continue Do®;
+                                                                ®break If®;
+                                                                ®break Switch®;
                                                         } // switch
                                                 } else {
                                                         ... @break If@; ...     // terminate if
+                                                        ... ®break If®; ...     // terminate if
                                                 } // if
                                 } while ( ... ); // do
                         } // while
                 } // for
         } @finally@ { // always executed
+        } ®finally® { // always executed
         } // try
 } // compound
 …
+{
                 @ForC:@ for ( ... ) {
                         @WhileC:@ while ( ... ) {
                                 @DoC:@ do {
+                ®ForC:® for ( ... ) {
+                        ®WhileC:® while ( ... ) {
+                                ®DoC:® do {
                                         if ( ... ) {
                                                 switch ( ... ) {
                                                         case 3:
                                                                 @goto Compound@;
                                                                 @goto Try@;
                                                                 @goto ForB@;      /* or */  @goto ForC@;
                                                                 @goto WhileB@;  /* or */  @goto WhileC@;
                                                                 @goto DoB@;      /* or */  @goto DoC@;
                                                                 @goto If@;
                                                                 @goto Switch@;
                                                         } @Switch:@ ;
+                                                                ®goto Compound®;
+                                                                ®goto Try®;
+                                                                ®goto ForB®;      /* or */  ®goto ForC®;
+                                                                ®goto WhileB®;  /* or */  ®goto WhileC®;
+                                                                ®goto DoB®;      /* or */  ®goto DoC®;
+                                                                ®goto If®;
+                                                                ®goto Switch®;
+                                                        } ®Switch:® ;
                                                 } else {
                                                         ... @goto If@; ...      // terminate if
                                                 } @If:@;
                                 } while ( ... ); @DoB:@ ;
                         } @WhileB:@ ;
                 } @ForB:@ ;
 } @Compound:@ ;
+                                                        ... ®goto If®; ...      // terminate if
+                                                } ®If:®;
+                                } while ( ... ); ®DoB:® ;
+                        } ®WhileB:® ;
+                } ®ForB:® ;
+} ®Compound:® ;
 \end{cfa}
 \end{lrbox}
 …
 %\subsection{\texorpdfstring{\protect\lstinline@with@ Statement}{with Statement}}
+%\subsection{\texorpdfstring{\protect\lstinline{with} Statement}{with Statement}}
 \subsection{\texorpdfstring{\LstKeywordStyle{with} Statement}{with Statement}}
 \label{s:WithStatement}
 …
 \begin{cfa}
 Person p
 @p.@name; @p.@address; @p.@sex; $\C{// access containing fields}$
+®p.®name; ®p.®address; ®p.®sex; $\C{// access containing fields}$
 \end{cfa}
 which extends to multiple levels of qualification for nested aggregates and multiple aggregates.
 \begin{cfa}
 struct Ticket { ... } t;
 @p.name@.first; @p.address@.street;             $\C{// access nested fields}$
 @t.@departure; @t.@cost;                                $\C{// access multiple aggregate}$
+®p.name®.first; ®p.address®.street;             $\C{// access nested fields}$
+®t.®departure; ®t.®cost;                                $\C{// access multiple aggregate}$
 \end{cfa}
 Repeated aggregate qualification is tedious and makes code difficult to read.
 …
 \begin{C++}
 struct S {
         char @c@;   int @i@;   double @d@;
+        char ®c®;   int ®i®;   double ®d®;
         void f( /* S * this */ ) {                              $\C{// implicit ``this'' parameter}$
                 @c@;   @i@;   @d@;                                      $\C{// this->c; this->i; this->d;}$
+                ®c®;   ®i®;   ®d®;                                      $\C{// this->c; this->i; this->d;}$
+        }
+}
 …
 \begin{cfa}
 struct T {
         char @m@;   int @i@;   double @n@;              $\C{// derived class variables}$
+        char ®m®;   int ®i®;   double ®n®;              $\C{// derived class variables}$
 };
 struct S : public T {
         char @c@;   int @i@;   double @d@;              $\C{// class variables}$
         void g( double @d@, T & t ) {
                 d;   @t@.m;   @t@.i;   @t@.n;           $\C{// function parameter}$
                 c;   i;   @this->@d;   @S::@d;          $\C{// class S variables}$
                 m;   @T::@i;   n;                                       $\C{// class T variables}$
+        char ®c®;   int ®i®;   double ®d®;              $\C{// class variables}$
+        void g( double ®d®, T & t ) {
+                d;   ®t®.m;   ®t®.i;   ®t®.n;           $\C{// function parameter}$
+                c;   i;   ®this->®d;   ®S::®d;          $\C{// class S variables}$
+                m;   ®T::®i;   n;                                       $\C{// class T variables}$
+        }
 };
 …
 Hence, the qualified fields become variables with the side-effect that it is simpler to write, easier to read, and optimize field references in a block.
 \begin{cfa}
 void f( S & this ) @with ( this )@ {            $\C{// with statement}$
         @c@;   @i@;   @d@;                                              $\C{// this.c, this.i, this.d}$
+void f( S & this ) ®with ( this )® {            $\C{// with statement}$
+        ®c®;   ®i®;   ®d®;                                              $\C{// this.c, this.i, this.d}$
+}
 \end{cfa}
 with the generality of opening multiple aggregate-parameters:
 \begin{cfa}
 void g( S & s, T & t ) @with ( s, t )@ {        $\C{// multiple aggregate parameters}$
         c;   @s.@i;   d;                                                $\C{// s.c, s.i, s.d}$
         m;   @t.@i;   n;                                                $\C{// t.m, t.i, t.n}$
+void g( S & s, T & t ) ®with ( s, t )® {        $\C{// multiple aggregate parameters}$
+        c;   ®s.®i;   d;                                                $\C{// s.c, s.i, s.d}$
+        m;   ®t.®i;   n;                                                $\C{// t.m, t.i, t.n}$
+}
 \end{cfa}
 …
 The difference between parallel and nesting occurs for fields with the same name and type:
 \begin{cfa}
 struct Q { int @i@; int k; int @m@; } q, w;
 struct R { int @i@; int j; double @m@; } r, w;
+struct Q { int ®i®; int k; int ®m®; } q, w;
+struct R { int ®i®; int j; double ®m®; } r, w;
 with ( r, q ) {
         j + k;                                                                  $\C{// unambiguous, r.j + q.k}$
 …
 \begin{cfa}
 void ?{}( S & s, int i ) with ( s ) { $\C{// constructor}$
         @s.i = i;@  j = 3;  m = 5.5; $\C{// initialize fields}$
+        ®s.i = i;®  j = 3;  m = 5.5; $\C{// initialize fields}$
+}
 \end{cfa}
 …
 and implicitly opened \emph{after} a function-body open, to give them higher priority:
 \begin{cfa}
 void ?{}( S & s, int @i@ ) with ( s ) @with( $\emph{\R{params}}$ )@ { // syntax not allowed, illustration only
         s.i = @i@; j = 3; m = 5.5;
+void ?{}( S & s, int ®i® ) with ( s ) ®with( $\emph{\R{params}}$ )® { // syntax not allowed, illustration only
+        s.i = ®i®; j = 3; m = 5.5;
+}
 \end{cfa}
 …
 For example, a routine returning a \Index{pointer} to an array of integers is defined and used in the following way:
 \begin{cfa}
 int @(*@f@())[@5@]@ {...}; $\C{// definition}$
  ... @(*@f@())[@3@]@ += 1; $\C{// usage}$
+int ®(*®f®())[®5®]® {...}; $\C{// definition}$
+ ... ®(*®f®())[®3®]® += 1; $\C{// usage}$
 \end{cfa}
 Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}).
 …
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}[moredelim={**[is][\color{blue}]{\#}{\#}}]
 #[5] *# @int@ x1;
 #* [5]# @int@ x2;
 #[* [5] int]# f@( int p )@;
+#[5] *# ®int® x1;
+#* [5]# ®int® x2;
+#[* [5] int]# f®( int p )®;
 \end{cfa}
+&
 \begin{cfa}[moredelim={**[is][\color{blue}]{\#}{\#}}]
 @int@ #*# x1 #[5]#;
 @int@ #(*#x2#)[5]#;
 #int (*#f@( int p )@#)[5]#;
+®int® #*# x1 #[5]#;
+®int® #(*#x2#)[5]#;
+#int (*#f®( int p )®#)[5]#;
 \end{cfa}
 \end{tabular}
 …
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 @*@ int x, y;
+®*® int x, y;
 \end{cfa}
+&
 \begin{cfa}
 int @*@x, @*@y;
+int ®*®x, ®*®y;
 \end{cfa}
 \end{tabular}
 …
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 @*@ int x;
+®*® int x;
 int y;
 \end{cfa}
+&
 \begin{cfa}
 int @*@x, y;
+int ®*®x, y;
 \end{cfa}
 …
+&
 \begin{cfa}
 int * @const@ x = (int *)100
+int * ®const® x = (int *)100
 *x = 3;                 // implicit dereference
 int * @const@ y = (int *)104;
+int * ®const® y = (int *)104;
 *y = *x;                        // implicit dereference
 \end{cfa}
 …
 \begin{tabular}{@{}l@{\hspace{2em}}l@{}}
 \begin{cfa}
 int x, y, @*@ p1, @*@ p2, @**@ p3;
 p1 = @&@x;     // p1 points to x
+int x, y, ®*® p1, ®*® p2, ®**® p3;
+p1 = ®&®x;     // p1 points to x
 p2 = p1;     // p2 points to x
 p1 = @&@y;     // p1 points to y
+p1 = ®&®y;     // p1 points to y
 p3 = &p2;  // p3 points to p2
 \end{cfa}
 …
 \begin{cfa}
 p1 = p2; $\C{// pointer address assignment}$
 @*@p2 = @*@p1 + x; $\C{// pointed-to value assignment / operation}$
+®*®p2 = ®*®p1 + x; $\C{// pointed-to value assignment / operation}$
 \end{cfa}
 The C semantics work well for situations where manipulation of addresses is the primary meaning and data is rarely accessed, such as storage management (©malloc©/©free©).
 …
 To support this common case, a reference type is introduced in \CFA, denoted by ©&©, which is the opposite dereference semantics to a pointer type, making the value at the pointed-to location the implicit semantics for dereferencing (similar but not the same as \CC \Index{reference type}s).
 \begin{cfa}
 int x, y, @&@ r1, @&@ r2, @&&@ r3;
 @&@r1 = &x; $\C{// r1 points to x}$
 @&@r2 = &r1; $\C{// r2 points to x}$
 @&@r1 = &y; $\C{// r1 points to y}$
 @&&@r3 = @&@&r2; $\C{// r3 points to r2}$
+int x, y, ®&® r1, ®&® r2, ®&&® r3;
+®&®r1 = &x; $\C{// r1 points to x}$
+®&®r2 = &r1; $\C{// r2 points to x}$
+®&®r1 = &y; $\C{// r1 points to y}$
+®&&®r3 = ®&®&r2; $\C{// r3 points to r2}$
 r2 = ((r1 + r2) * (r3 - r1)) / (r3 - 15); $\C{// implicit dereferencing}$
 \end{cfa}
 …
 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 a declaration, so the previous example becomes:
 \begin{cfa}
 @*@r2 = ((@*@r1 + @*@r2) @*@ (@**@r3 - @*@r1)) / (@**@r3 - 15);
+®*®r2 = ((®*®r1 + ®*®r2) ®*® (®**®r3 - ®*®r1)) / (®**®r3 - 15);
 \end{cfa}
 When a reference operation appears beside a dereference operation, \eg ©&*©, they cancel out.
 …
 For a \CFA reference type, the cancellation on the left-hand side of assignment leaves the reference as an address (\Index{lvalue}):
 \begin{cfa}
 (&@*@)r1 = &x; $\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}$
+(&®*®)r1 = &x; $\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}$
 \end{cfa}
 Similarly, the address of a reference can be obtained for assignment or computation (\Index{rvalue}):
 \begin{cfa}
 (&(&@*@)@*@)r3 = &(&@*@)r2; $\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}$
+(&(&®*®)®*®)r3 = &(&®*®)r2; $\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}$
 \end{cfa}
 Cancellation\index{cancellation!pointer/reference}\index{pointer!cancellation} works to arbitrary depth.
 …
 const int cx = 5; $\C{// cannot change cx;}$
 const int & cr = cx; $\C{// cannot change what cr points to}$
 @&@cr = &cx; $\C{// can change cr}$
+®&®cr = &cx; $\C{// can change cr}$
 cr = 7; $\C{// error, cannot change cx}$
 int & const rc = x; $\C{// must be initialized}$
 @&@rc = &x; $\C{// error, cannot change rc}$
+®&®rc = &x; $\C{// error, cannot change rc}$
 const int & const crc = cx; $\C{// must be initialized}$
 crc = 7; $\C{// error, cannot change cx}$
 @&@crc = &cx; $\C{// error, cannot change crc}$
+®&®crc = &cx; $\C{// error, cannot change crc}$
 \end{cfa}
 Hence, for type ©& const©, there is no pointer assignment, so ©&rc = &x© is disallowed, and \emph{the address value cannot be the null pointer unless an arbitrary pointer is coerced\index{coercion} into the reference}:
 …
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 @const@ * @const@ * const int ccp;
 @const@ & @const@ & const int ccr;
+®const® * ®const® * const int ccp;
+®const® & ®const® & const int ccr;
 \end{cfa}
+&
 \begin{cfa}
 const int * @const@ * @const@ ccp;
+const int * ®const® * ®const® ccp;
 \end{cfa}
 …
 \begin{cfa}
 int * p = &x; $\C{// assign address of x}$
 @int * p = x;@ $\C{// assign value of x}$
+®int * p = x;® $\C{// assign value of x}$
 int & r = x; $\C{// must have address of x}$
 \end{cfa}
 …
 When a pointer/reference parameter has a ©const© value (immutable), it is possible to pass literals and expressions.
 \begin{cfa}
 void f( @const@ int & cr );
 void g( @const@ int * cp );
 f( 3 );                   g( @&@3 );
 f( x + y );             g( @&@(x + y) );
+void f( ®const® int & cr );
+void g( ®const® int * cp );
+f( 3 );                   g( ®&®3 );
+f( x + y );             g( ®&®(x + y) );
 \end{cfa}
 Here, the compiler passes the address to the literal 3 or the temporary for the expression ©x + y©, knowing the argument cannot be changed through the parameter.
 …
 void f( int & r );
 void g( int * p );
 f( 3 );                   g( @&@3 ); $\C{// compiler implicit generates temporaries}$
 f( x + y );             g( @&@(x + y) ); $\C{// compiler implicit generates temporaries}$
+f( 3 );                   g( ®&®3 ); $\C{// compiler implicit generates temporaries}$
+f( x + y );             g( ®&®(x + y) ); $\C{// compiler implicit generates temporaries}$
 \end{cfa}
 Essentially, there is an implicit \Index{rvalue} to \Index{lvalue} conversion in this case.\footnote{
 …
 Instead, a routine object should be referenced by a ©const© reference:
 \begin{cfa}
 @const@ void (@&@ fr)( int ) = f; $\C{// routine reference}$
+®const® void (®&® fr)( int ) = f; $\C{// routine reference}$
 fr = ... $\C{// error, cannot change code}$
 &fr = ...; $\C{// changing routine reference}$
 …
 \begin{cfa}
 int x, &r = x, f( int p );
 x = @r@ + f( @r@ ); $\C{// lvalue reference converts to rvalue}$
+x = ®r® + f( ®r® ); $\C{// lvalue reference converts to rvalue}$
 \end{cfa}
 An rvalue has no type qualifiers (©cv©), so the reference qualifiers are dropped.
 \item
 lvalue to reference conversion: \lstinline[deletekeywords=lvalue]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references.
 \begin{cfa}
 int x, &r = @x@, f( int & p ); $\C{// lvalue variable (int) convert to reference (int \&)}$
 f( @x@ ); $\C{// lvalue variable (int) convert to reference (int \&)}$
+lvalue to reference conversion: \lstinline[deletekeywords=lvalue]{lvalue-type cv1 T} converts to ©cv2 T &©, which allows implicitly converting variables to references.
+\begin{cfa}
+int x, &r = ®x®, f( int & p ); $\C{// lvalue variable (int) convert to reference (int \&)}$
+f( ®x® ); $\C{// lvalue variable (int) convert to reference (int \&)}$
 \end{cfa}
 Conversion can restrict a type, where ©cv1© $\le$ ©cv2©, \eg passing an ©int© to a ©const volatile int &©, which has low cost.
 …
 \begin{cfa}
 int x, & f( int & p );
 f( @x + 3@ );   $\C[1.5in]{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}$
 @&f@(...) = &x; $\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}\CRT$
+f( ®x + 3® );   $\C[1.5in]{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}$
+®&f®(...) = &x; $\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}\CRT$
 \end{cfa}
 In both case, modifications to the temporary are inaccessible (\Index{warning}).
 …
+\section{Enumeration}
+An \newterm{enumeration} is a compile-time mechanism to alias names to constants, like ©typedef© is a mechanism to alias names to types.
+Its purpose is to define a restricted-value type providing code-readability and maintenance -- changing an enum's value automatically updates all name usages during compilation.
+An enumeration type is a set of names, each called an \newterm{enumeration constant} (shortened to \newterm{enum}) aliased to a fixed value (constant).
+\begin{cfa}
+enum Days { Mon, Tue, Wed, Thu, Fri, Sat, Sun }; // enumeration type definition, set of 7 names & values
+Days days = Mon; // enumeration type declaration and initialization
+\end{cfa}
+The set of enums are injected into the variable namespace at the definition scope.
+Hence, enums may be overloaded with enum/variable/function names.
+\begin{cfa}
+enum Foo { Bar };
+enum Goo { Bar };       $\C[1.75in]{// overload Foo.Bar}$
+int Foo;                        $\C{// type/variable separate namespace}$
+double Bar;                     $\C{// overload Foo.Bar, Goo.Bar}\CRT$
+\end{cfa}
+An anonymous enumeration injects enums with specific values into a scope.
+\begin{cfa}
+enum { Prime = 103, BufferSize = 1024 };
+\end{cfa}
+An enumeration is better than using C \Index{preprocessor} or constant declarations.
+\begin{cquote}
+\begin{tabular}{@{}l@{\hspace{4em}}l@{}}
+\begin{cfa}
+#define Mon 0
+...
+#define Sun 6
+\end{cfa}
+&
+\begin{cfa}
+const int Mon = 0,
+                         ...,
+                         Sun = 6;
+\end{cfa}
+\end{tabular}
+\end{cquote}
+because the enumeration is succinct, has automatic numbering, can appear in ©case© labels, does not use storage, and is part of the language type-system.
+Finally, the type of an enum is implicitly or explicitly specified and the constant value can be implicitly or explicitly specified.
+Note, enum values may be repeated in an enumeration.
+\subsection{Enum type}
+The type of enums can be any type, and an enum's value comes from this type.
+Because an enum is a constant, it cannot appear in a mutable context, \eg ©Mon = Sun© is disallowed, and has no address (it is an rvalue).
+Therefore, an enum is automatically converted to its constant's base-type, \eg comparing/printing an enum compares/prints its value rather than the enum name;
+there is no mechanism to print the enum name.
+The default enum type is ©int©.
+Hence, ©Days© is the set type ©Mon©, ©Tue©, ...\,, ©Sun©, while the type of each enum is ©int© and each enum represents a fixed integral value.
+If no values are specified for an integral enum type, the enums are automatically numbered by one from left to right starting at zero.
+Hence, the value of enum ©Mon© is 0, ©Tue© is 1, ...\,, ©Sun© is 6.
+If an enum value is specified, numbering continues by one from that value for subsequent unnumbered enums.
+If an enum value is an expression, the compiler performs constant-folding to obtain a constant value.
+\CFA allows other integral types with associated values.
+\begin{cfa}
+enum( ®char® ) Letter { A ®= 'A'®,  B,  C,  I ®= 'I'®,  J,  K };
+enum( ®long long int® ) BigNum { X = 123_456_789_012_345,  Y = 345_012_789_456_123 };
+\end{cfa}
+For enumeration ©Letter©, enum ©A©'s value is explicitly set to ©'A'©, with ©B© and ©C© implicitly numbered with increasing values from ©'A'©, and similarly for enums ©I©, ©J©, and ©K©.
+Non-integral enum types must be explicitly initialized, \eg ©double© is not automatically numbered by one.
+\begin{cfa}
+// non-integral numeric
+enum( ®double® ) Math { PI_2 = 1.570796, PI = 3.141597,  E = 2.718282 }
+// pointer
+enum( ®char *® ) Name { Fred = "Fred",  Mary = "Mary",  Jane = "Jane" };
+int i, j, k;
+enum( ®int *® ) ptr { I = &i,  J = &j,  K = &k };
+enum( ®int &® ) ref { I = i,  J = j,  K = k };
+// tuple
+enum( ®[int, int]® ) { T = [ 1, 2 ] };
+// function
+void f() {...}   void g() {...}
+enum( ®void (*)()® ) funs { F = f,  F = g };
+// aggregate
+struct S { int i, j; };
+enum( ®S® ) s { A = { 3,  4 }, B = { 7,  8 } };
+// enumeration
+enum( ®Letter® ) Greek { Alph = A, Beta = B, /* more enums */  }; // alphabet intersection
+\end{cfa}
+Enumeration ©Greek© may have more or less enums than ©Letter©, but the enum values \emph{must} be from ©Letter©.
+Therefore, ©Greek© enums are a subset of type ©Letter© and are type compatible with enumeration ©Letter©, but ©Letter© enums are not type compatible with enumeration ©Greek©.
+The following examples illustrate the difference between the enumeration type and the type of its enums.
+\begin{cfa}
+Math m = PI;    $\C[1.5in]{// allowed}$
+double d = PI;  $\C{// allowed, conversion to base type}$
+m = E;                  $\C{// allowed}$
+m = Alph;               $\C{// {\color{red}disallowed}}$
+m = 3.141597;   $\C{// {\color{red}disallowed}}$
+d = m;                  $\C{// allowed}$
+d = Alph;               $\C{// {\color{red}disallowed}}$
+Letter l = A;   $\C{// allowed}$
+Greek g = Alph; $\C{// allowed}$
+l = Alph;               $\C{// allowed, conversion to base type}$
+g = A;                  $\C{// {\color{red}disallowed}}\CRT$
+\end{cfa}
+A constructor \emph{cannot} be used to initialize enums because a constructor executes at runtime.
+A fallback is explicit C-style initialization using ©@=©.
+\begin{cfa}
+enum( struct vec3 ) Axis { Up @= { 1, 0, 0 }, Left @= { 0, 1, 0 }, Front @= { 0, 0, 1 } }
+\end{cfa}
+Finally, enumeration variables are assignable and comparable only if the appropriate operators are defined for its enum type.
+\subsection{Inheritance}
+\Index{Plan-9}\index{inheritance!enumeration} inheritance may be used with enumerations.
+\begin{cfa}
+enum( char * ) Name2 { ®inline Name®, Jack = "Jack", Jill = "Jill" };
+enum ®/* inferred */®  Name3 { ®inline Name2®, Sue = "Sue", Tom = "Tom" };
+\end{cfa}
+Enumeration ©Name2© inherits all the enums and their values from enumeration ©Name© by containment, and a ©Name© enumeration is a subtype of enumeration ©Name2©.
+Note, enums must be unique in inheritance but enum values may be repeated.
+The enum type for the inheriting type must be the same as the inherited type;
+hence the enum type may be omitted for the inheriting enumeration and it is inferred from the inherited enumeration, as for ©Name3©.
+When inheriting from integral types, automatic numbering may be used, so the inheritance placement left to right is important, \eg the placement of ©Sue© and ©Tom© before or after ©inline Name2©.
+Specifically, the inheritance relationship for ©Name©s is:
+\begin{cfa}
+Name $\(\subseteq\)$ Name2 $\(\subseteq\)$ Name3 $\(\subseteq\)$ const char * // enum type of Name
+\end{cfa}
+Hence, given
+\begin{cfa}
+void f( Name );
+void g( Name2 );
+void h( Name3 );
+void j( const char * );
+\end{cfa}
+the following calls are valid
+\begin{cfa}
+f( Fred );
+g( Fred );   g( Jill );
+h( Fred );   h( Jill );   h( Sue );
+j( Fred );    j( Jill );    j( Sue );    j( 'W' );
+\end{cfa}
+Note, the validity of calls is the same for call-by-reference as for call-by-value, and ©const© restrictions are the same as for other types.
+Enums cannot be created at runtime, so inheritence problems, such as contra-variance do not apply.
+Only instances of the enum base-type may be created at runtime.
+\begin{comment}
+The invariance of references, as I show at the bottom, is easy to overlook.  Not shown, but on the same topic, is that returns work in the opposite direction as parameters.  Hopefully our existing type rules already know both those facts, so that we'd only have to provide the rules that I suggest using the by-value parameters.
+The Fred, Jack, and Mary declarations are picked verbatim from our earlier whiteboard, just repeated here for reference.
+\begin{cfa}
+// Fred is a subset of char *
+enum( char *) Fred { A = "A", B = "B", C = "C" };
+// Jack is a subset of Fred
+enum( enum Fred ) Jack { W = A, Y = C};
+// Mary is a superset of Fred
+enum Mary { inline Fred, D = "hello" };
+// Demonstrating invariance of references
+[void] frcs( & * char x ) { char * x0 = x; x = "bye"; }
+[void] frf ( & Fred   x ) { Fred   x0 = x; x = B;     }
+[void] frj ( & Jack   x ) { Jack   x0 = x; x = W;     }
+[void] frm ( & Mary   x ) { Mary   x0 = x; x = D;     }
+char * vcs;
+Fred   vf;
+Jack   vj;
+Mary   vm;
+// all variant calls: bad  (here are noteworthy examples)
+             frcs( vf  );  // can't assign "bye" to vf
+             frm ( vf  );  // can't assign D     to vf
+             frf ( vj  );  // can't assign B     to vj
+vf  = B    ; frj ( vf  );  // can't assign B     to frj.x0
+vcs = "bye"; frf ( vcs );  // can't assign "bye" to frf.x0
+\end{cfa}
+This example is really great. However, I think it's work explicitly doing one with ©const &©.
+\end{comment}
 \section{Routine Definition}
 \CFA also supports a new syntax for routine definition, as well as \Celeven and K\&R routine syntax.
+\CFA supports a new syntax for routine definition, as well as \Celeven and K\&R routine syntax.
 The point of the new syntax is to allow returning multiple values from a routine~\cite{Galletly96,CLU}, \eg:
 \begin{cfa}
 @[ int o1, int o2, char o3 ]@ f( int i1, char i2, char i3 ) {
+®[ int o1, int o2, char o3 ]® f( int i1, char i2, char i3 ) {
         $\emph{routine body}$
+}
 \end{cfa}
 where routine ©f© has three output (return values) and three input parameters.
 Existing C syntax cannot be extended with multiple return types because it is impossible to embed a single routine name within multiple return type specifications.
+Existing C syntax cannot be extended with multiple return types because it is impossible to embed a single routine name within multiple return type-specifications.
 In detail, the brackets, ©[]©, enclose the result type, where each return value is named and that name is a local variable of the particular return type.\footnote{
 …
 Declaration qualifiers can only appear at the start of a routine definition, \eg:
 \begin{cfa}
 @extern@ [ int x ] g( int y ) {$\,$}
+®extern® [ int x ] g( int y ) {$\,$}
 \end{cfa}
 Lastly, if there are no output parameters or input parameters, the brackets and/or parentheses must still be specified;
 …
 int (*f(x))[ 5 ] int x; {}
 \end{cfa}
 The string ``©int (*f(x))[ 5 ]©'' declares a K\&R style routine of type returning a pointer to an array of 5 integers, while the string ``©[ 5 ] int x©'' declares a \CFA style parameter x of type array of 5 integers.
+The string ``©int (*f(x))[ 5 ]©'' declares a K\&R style routine of type returning a pointer to an array of 5 integers, while the string ``©[ 5 ] int x©'' declares a \CFA style parameter ©x© of type array of 5 integers.
 Since the strings overlap starting with the open bracket, ©[©, there is an ambiguous interpretation for the string.
 As well, \CFA-style declarations cannot be used to declare parameters for C-style routine-definitions because of the following ambiguity:
 …
 \begin{minipage}{\linewidth}
 \begin{cfa}
 @[ int x, int y ]@ f() {
+®[ int x, int y ]® f() {
         int z;
         ... x = 0; ... y = z; ...
         @return;@ $\C{// implicitly return x, y}$
+        ®return;® $\C{// implicitly return x, y}$
+}
 \end{cfa}
 …
 int fred() {
         s.t.c = @S.@R;  // type qualification
         struct @S.@T t = { @S.@R, 1, 2 };
         enum @S.@C c;
         union @S.T.@U u;
+        s.t.c = ®S.®R;  // type qualification
+        struct ®S.®T t = { ®S.®R, 1, 2 };
+        enum ®S.®C c;
+        union ®S.T.®U u;
+}
 \end{cfa}
 …
 qsort( ia, size ); $\C{// sort ascending order using builtin ?<?}$
+{
         @int ?<?( int x, int y ) { return x > y; }@ $\C{// nested routine}$
+        ®int ?<?( int x, int y ) { return x > y; }® $\C{// nested routine}$
         qsort( ia, size ); $\C{// sort descending order by local redefinition}$
+}
 …
 \begin{cfa}
 [* [int]( int )] foo() { $\C{// int (* foo())( int )}$
         int @i@ = 7;
+        int ®i® = 7;
         int bar( int p ) {
                 @i@ += 1; $\C{// dependent on local variable}$
                 sout | @i@;
+                ®i® += 1; $\C{// dependent on local variable}$
+                sout | ®i®;
+        }
         return bar; $\C{// undefined because of local dependence}$
 …
 In C and \CFA, lists of elements appear in several contexts, such as the parameter list of a routine call.
 \begin{cfa}
 f( @2, x, 3 + i@ ); $\C{// element list}$
+f( ®2, x, 3 + i® ); $\C{// element list}$
 \end{cfa}
 A list of elements is called a \newterm{tuple}, and is different from a \Index{comma expression}.
 …
 In \CFA, it is possible to overcome this restriction by declaring a \newterm{tuple variable}.
 \begin{cfa}
 [int, int] @qr@ = div( 13, 5 ); $\C{// initialize tuple variable}$
 printf( "%d %d\n", @qr@ ); $\C{// print quotient/remainder}$
+[int, int] ®qr® = div( 13, 5 ); $\C{// initialize tuple variable}$
+printf( "%d %d\n", ®qr® ); $\C{// print quotient/remainder}$
 \end{cfa}
 It is now possible to match the multiple return-values to a single variable, in much the same way as \Index{aggregation}.
 …
 \begin{cfa}
 int x = 1, y = 2, z = 3;
 sout | x @|@ y @|@ z;
+sout | x ®|® y ®|® z;
 \end{cfa}
+&
 \begin{cfa}
 cout << x @<< " "@ << y @<< " "@ << z << endl;
+cout << x ®<< " "® << y ®<< " "® << z << endl;
 \end{cfa}
+&
 …
 \\
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @ @2@ @3
+® ®2® ®3
 \end{cfa}
+&
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @ @2@ @3
+® ®2® ®3
 \end{cfa}
+&
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @ @2@ @3
+® ®2® ®3
 \end{cfa}
 \end{tabular}
 \end{cquote}
 The \CFA form has half the characters of the \CC form, and is similar to \Index*{Python} I/O with respect to implicit separators and newline.
 Similar simplification occurs for \Index{tuple} I/O, which flattens the tuple and prints each value separated by ``\lstinline[showspaces=true]@, @''.
+Similar simplification occurs for \Index{tuple} I/O, which flattens the tuple and prints each value separated by ``\lstinline[showspaces=true]{, }''.
 \begin{cfa}
 [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ];
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 @, @2@, @3 4@, @5@, @6
+®, ®2®, ®3 4®, ®5®, ®6
 \end{cfa}
 Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority \emph{overloadable} operator, other than assignment.
 …
+&
 \begin{cfa}
 sout | x * 3 | y + 1 | z << 2 | x == y | @(@x | y@)@ | @(@x || y@)@ | @(@x > z ? 1 : 2@)@;
+sout | x * 3 | y + 1 | z << 2 | x == y | ®(®x | y®)® | ®(®x || y®)® | ®(®x > z ? 1 : 2®)®;
 \end{cfa}
 \\
 …
+&
 \begin{cfa}
 cout << x * 3 << y + 1 << @(@z << 2@)@ << @(@x == y@)@ << @(@x | y@)@ << @(@x || y@)@ << @(@x > z ? 1 : 2@)@ << endl;
+cout << x * 3 << y + 1 << ®(®z << 2®)® << ®(®x == y®)® << ®(®x | y®)® << ®(®x || y®)® << ®(®x > z ? 1 : 2®)® << endl;
 \end{cfa}
 \\
 …
 \\
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+@1@ @2.5@ @A@
+®1® ®2.5® ®A®
 …
+&
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+@1@ @2.5@ @A@
+®1® ®2.5® ®A®
 …
+&
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+@1@
+@2.5@
+@A@
+®1®
+®2.5®
+®A®
 \end{cfa}
 \end{tabular}
 …
 \item
 A separator does not appear before a C string starting with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \LstStringStyle{,.;!?)]\}\%\textcent\guillemotright}, where \LstStringStyle{\guillemotright} a closing citation mark.
+A separator does not appear before a C string starting with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \LstStringStyle{,.;!?)]\}\%\textcent\guillemotright}, where \LstStringStyle{\guillemotright} is a closing citation mark.
 \begin{cfa}
 sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x"
 …
 \end{cfa}
 \begin{cfa}[showspaces=true]
 @,@ x 2@.@ x 3@;@ x 4@!@ x 5@?@ x 6@%@ x 7$\R{\LstStringStyle{\textcent}}$ x 8$\R{\LstStringStyle{\guillemotright}}$ x 9@)@ x 10@]@ x 11@}@ x
+®,® x 2®.® x 3®;® x 4®!® x 5®?® x 6®%® x 7$\R{\LstStringStyle{\textcent}}$ x 8$\R{\LstStringStyle{\guillemotright}}$ x 9®)® x 10®]® x 11®}® x
 \end{cfa}
 …
 %$
 \begin{cfa}
 sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $" | 5 | "x $\LstStringStyle{\textsterling}$" | 6 | "x $\LstStringStyle{\textyen}$"
+sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $\LstStringStyle{\textdollar}$" | 5 | "x $\LstStringStyle{\textsterling}$" | 6 | "x $\LstStringStyle{\textyen}$"
            | 7 | "x $\LstStringStyle{\textexclamdown}$" | 8 | "x $\LstStringStyle{\textquestiondown}$" | 9 | "x $\LstStringStyle{\guillemotleft}$" | 10;
 \end{cfa}
 %$
 \begin{cfa}[showspaces=true]
 x @(@1 x @[@2 x @{@3 x @=@4 x $\LstStringStyle{\textdollar}$5 x $\R{\LstStringStyle{\textsterling}}$6 x $\R{\LstStringStyle{\textyen}}$7 x $\R{\LstStringStyle{\textexclamdown}}$8 x $\R{\LstStringStyle{\textquestiondown}}$9 x $\R{\LstStringStyle{\guillemotleft}}$10
+x ®(®1 x ®[®2 x ®{®3 x ®=®4 x $\LstStringStyle{\textdollar}$5 x $\R{\LstStringStyle{\textsterling}}$6 x $\R{\LstStringStyle{\textyen}}$7 x $\R{\LstStringStyle{\textexclamdown}}$8 x $\R{\LstStringStyle{\textquestiondown}}$9 x $\R{\LstStringStyle{\guillemotleft}}$10
 \end{cfa}
 %$
 \item
 A seperator does not appear before/after a C string starting/ending with the \Index*{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]{`'": \t\v\f\r\n}
+A separator does not appear before/after a C string starting/ending with the \Index*{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]{`'": \t\v\f\r\n}
 \begin{cfa}
 sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx";
 \end{cfa}
 \begin{cfa}[showspaces=true,showtabs=true]
 x@`@1@`@x$\R{\texttt{'}}$2$\R{\texttt{'}}$x$\R{\texttt{"}}$3$\R{\texttt{"}}$x@:@4@:@x@ @5@ @x@  @6@     @x
+x®`®1®`®x$\R{\texttt{'}}$2$\R{\texttt{'}}$x$\R{\texttt{"}}$3$\R{\texttt{"}}$x®:®4®:®x® ®5® ®x®  ®6®     ®x
 \end{cfa}
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,showtabs=true]
 x (@ @1@ @) x 2@ @, x 3@ @:x:@ @4
+x (® ®1® ®) x 2® ®, x 3® ®:x:® ®4
 \end{cfa}
 \end{enumerate}
 …
 \Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} and \Indexc{sep}\index{manipulator!sep@©sep©}/\Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} set and get the separator string.
 The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
+\begin{cfa}[escapechar=off,belowskip=0pt]
+sepSet( sout, ", $" ); $\C{// set separator from " " to ", \$"}$
+sout | 1 | 2 | 3 | " \"" | @sep@ | "\"";
+\end{cfa}
+%$
+\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
+@, $@2@, $@3 @", $"@
+\end{cfa}
+%$
+\begin{cfa}[belowskip=0pt]
+sepSet( sout, ", $\LstStringStyle{\textdollar}$" ); $\C{// set separator from " " to ", \$"}$
+sout | 1 | 2 | 3 | " \"" | ®sep® | "\"";
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt]
+®, $\LstStringStyle{\textdollar}$®2®, $\LstStringStyle{\textdollar}$®3 ®", $\LstStringStyle{\textdollar}$"®
+\end{cfa}
 \begin{cfa}[belowskip=0pt]
 sepSet( sout, " " ); $\C{// reset separator to " "}$
 sout | 1 | 2 | 3 | " \"" | @sepGet( sout )@ | "\"";
+sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 @ @2@ @3 @" "@
+® ®2® ®3 ®" "®
 \end{cfa}
 ©sepGet© can be used to store a separator and then restore it:
 \begin{cfa}[belowskip=0pt]
 char store[@sepSize@]; $\C{// sepSize is the maximum separator size}$
+char store[®sepSize®]; $\C{// sepSize is the maximum separator size}$
 strcpy( store, sepGet( sout ) ); $\C{// copy current separator}$
 sepSet( sout, "_" ); $\C{// change separator to underscore}$
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @_@2@_@3
+®_®2®_®3
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 @ @2@ @3
+® ®2® ®3
 \end{cfa}
 …
 \begin{cfa}[belowskip=0pt]
 sepSetTuple( sout, " " ); $\C{// set tuple separator from ", " to " "}$
 sout | t1 | t2 | " \"" | @sepTuple@ | "\"";
+sout | t1 | t2 | " \"" | ®sepTuple® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 2 3 4 5 6 @" "@
+2 3 4 5 6 ®" "®
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
 sepSetTuple( sout, ", " ); $\C{// reset tuple separator to ", "}$
 sout | t1 | t2 | " \"" | @sepGetTuple( sout )@ | "\"";
+sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 , 2, 3 4, 5, 6 @", "@
+, 2, 3 4, 5, 6 ®", "®
 \end{cfa}
 As for ©sepGet©, ©sepGetTuple© can be use to store a tuple separator and then restore it.
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+@ @1 2 3@ @
+® ®1 2 3® ®
 \end{cfa}
 \end{enumerate}
 …
 For example, in:
 \begin{cfa}
 sin | i | @nl@ | j;
 @2@
+sin | i | ®nl® | j;
+®2®
 \end{cfa}
 …
 b0 0b11011 0b11011 0b11011 0b11011
 sout | bin( -27HH ) | bin( -27H ) | bin( -27 ) | bin( -27L );
 b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b@(58 1s)@100101
+b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b®(58 1s)®100101
 \end{cfa}
 …
 \item
+\Indexc{eng}( floating-point )\index{manipulator!eng@©eng©} print value in engineering notation with exponent, which means the exponent is adjusted to a multiple of 3.
+\begin{cfa}[belowskip=0pt]
+sout | eng( 0.0 ) | eng( 27000.5 ) | eng( -27.5e7 );
+®e0® 27.0005®e3® -275®e6®
+\end{cfa}
+\item
+\Indexc{unit}( engineering-notation )\index{manipulator!unit@©unit©} print engineering exponent as a letter between the range $10^{-24}$ and $10^{24}$:
+©y© $\Rightarrow 10^{-24}$, ©z© $\Rightarrow 10^{-21}$, ©a© $\Rightarrow 10^{-18}$, ©f© $\Rightarrow 10^{-15}$, ©p© $\Rightarrow 10^{-12}$, ©n© $\Rightarrow 10^{-9}$, ©u© $\Rightarrow 10^{-6}$, ©m© $\Rightarrow 10^{-3}$, ©K© $\Rightarrow 10^{3}$, ©M© $\Rightarrow 10^{6}$, ©G© $\Rightarrow 10^{9}$, ©T© $\Rightarrow 10^{12}$, ©P© $\Rightarrow 10^{15}$, ©E© $\Rightarrow 10^{18}$, ©Z© $\Rightarrow 10^{21}$, ©Y© $\Rightarrow 10^{24}$.
+For exponent $10^{0}$, no decimal point or letter is printed.
+\begin{cfa}[belowskip=0pt]
+sout | unit(eng( 0.0 )) | unit(eng( 27000.5 )) | unit(eng( -27.5e7 ));
+27.0005®K® -275®M®
+\end{cfa}
+\item
 \Indexc{upcase}( bin / hex / floating-point )\index{manipulator!upcase@©upcase©} print letters in a value in upper case. Lower case is the default.
 \begin{cfa}[belowskip=0pt]
 sout | upcase( bin( 27 ) ) | upcase( hex( 27 ) ) | upcase( 27.5e-10 ) | upcase( hex( 27.5 ) );
 @B@11011 0@X@1@B@ 2.75@E@-09 0@X@1.@B@8@P@+4
+®B®11011 0®X®1®B® 2.75®E®-09 0®X®1.®B®8®P®+4
 \end{cfa}
 …
 \begin{cfa}[belowskip=0pt]
 sout | 0. | nodp( 0. ) | 27.0 | nodp( 27.0 ) | nodp( 27.5 );
 .0 @0@ 27.0 @27@ 27.5
+.0 ®0® 27.0 ®27® 27.5
 \end{cfa}
 …
 \begin{cfa}[belowskip=0pt]
 sout | sign( 27 ) | sign( -27 ) | sign( 27. ) | sign( -27. ) | sign( 27.5 ) | sign( -27.5 );
 @+@27 -27 @+@27.0 -27.0 @+@27.5 -27.5
 \end{cfa}
 \item
 \Indexc{wd}©( unsigned char minimum, T val )©\index{manipulator!wd@©wd©}, ©wd( unsigned char minimum, unsigned char precision, T val )©
 For all types, ©minimum© is the minimum number of printed characters.
+®+®27 -27 ®+®27.0 -27.0 ®+®27.5 -27.5
+\end{cfa}
+\item
+\Indexc{wd}( minimum, value )\index{manipulator!wd@©wd©}, ©wd©( minimum, precision, value )
+For all types, minimum is the number of printed characters.
 If the value is shorter than the minimum, it is padded on the right with spaces.
 \begin{cfa}[belowskip=0pt]
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @  @34 @ @34 34
 @  @4.000000 @ @4.000000 4.000000
 @  @ab @ @ab ab
 \end{cfa}
 If the value is larger, it is printed without truncation, ignoring the ©minimum©.
+®  ®34 ® ®34 34
+®  ®4.000000 ® ®4.000000 4.000000
+®  ®ab ® ®ab ab
+\end{cfa}
+If the value is larger, it is printed without truncation, ignoring the minimum.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 4, 34567 ) | wd( 3, 34567 ) | wd( 2, 34567 );
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @7@ 345@67@ 34@567@
 @.@ 345@6.@ 34@56.@
 abcd@e@ abc@de@ ab@cde@
 \end{cfa}
 For integer types, ©precision© is the minimum number of printed digits.
+®7® 345®67® 34®567®
+®.® 345®6.® 34®56.®
+abcd®e® abc®de® ab®cde®
+\end{cfa}
+For integer types, precision is the minimum number of printed digits.
 If the value is shorter, it is padded on the left with leading zeros.
 \begin{cfa}[belowskip=0pt]
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
  @0@34     @00@34 @00000000@34
 \end{cfa}
 If the value is larger, it is printed without truncation, ignoring the ©precision©.
+ ®0®34     ®00®34 ®00000000®34
+\end{cfa}
+If the value is larger, it is printed without truncation, ignoring the precision.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 4,1, 3456 ) | wd( 8,2, 3456 ) | wd( 10,3, 3456 );
 …
      3456       3456
 \end{cfa}
 If ©precision© is 0, nothing is printed for zero.
 If ©precision© is greater than the minimum, it becomes the minimum.
+If precision is 0, nothing is printed for zero.
+If precision is greater than the minimum, it becomes the minimum.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 4,0, 0 ) | wd( 3,10, 34 );
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @    @ @00000000@34
 \end{cfa}
 For floating-point types, ©precision© is the minimum number of digits after the decimal point.
+®    ® ®00000000®34
+\end{cfa}
+For floating-point types, precision is the minimum number of digits after the decimal point.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 6,3, 27.5 ) | wd( 8,1, 27.5 ) | wd( 8,0, 27.5 ) | wd( 3,8, 27.5 );
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 .@500@     27.@5@      28. 27.@50000000@
 \end{cfa}
 For the C-string type, ©precision© is the maximum number of printed characters, so the string is truncated if it exceeds the maximum.
+.®500®     27.®5®      28. 27.®50000000®
+\end{cfa}
+For the C-string type, precision is the maximum number of printed characters, so the string is truncated if it exceeds the maximum.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 6,8, "abcd" ) | wd( 6,8, "abcdefghijk" ) | wd( 6,3, "abcd" );
 …
 \item
+\Indexc{ws( unsigned char minimum, unsigned char significant, floating-point )}\index{manipulator!ws@©ws©}
+For floating-point type, ©minimum© is the same as for manipulator ©wd©, but ©significant© is the maximum number of significant digits to be printed for both the integer and fractions (versus only the fraction for ©wd©).
+If a value's significant digits is greater than ©significant©, the last significant digit is rounded up.
+\begin{sloppypar}
+\Indexc{ws}( minimum, significant, floating-point )\index{manipulator!ws@©ws©}
+For floating-point types, minimum is the same as for manipulator ©wd©, but significant is the maximum number of significant digits to be printed for both the integer and fractions (versus only the fraction for ©wd©).
+If a value's significant digits is greater than significant, the last significant digit is rounded up.
+\end{sloppypar}
 \begin{cfa}[belowskip=0pt]
 sout | ws(6,6, 234.567) | ws(6,5, 234.567) | ws(6,4, 234.567) | ws(6,3, 234.567);
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 .567 234.5@7@  234.@6@    23@5@
 \end{cfa}
 If a value's magnitude is greater than ©significant©, the value is printed in scientific notation with the specified number of significant digits.
+.567 234.5®7®  234.®6®    23®5®
+\end{cfa}
+If a value's magnitude is greater than significant, the value is printed in scientific notation with the specified number of significant digits.
 \begin{cfa}[belowskip=0pt]
 sout | ws(6,6, 234567.) | ws(6,5, 234567.) | ws(6,4, 234567.) | ws(6,3, 234567.);
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 . 2.3457@e+05@ 2.346@e+05@ 2.35@e+05@
 \end{cfa}
 If ©significant© is greater than ©minimum©, it defines the number of printed characters.
+. 2.3457®e+05® 2.346®e+05® 2.35®e+05®
+\end{cfa}
+If significant is greater than minimum, it defines the number of printed characters.
 \begin{cfa}[belowskip=0pt]
 sout | ws(3,6, 234567.) | ws(4,6, 234567.) | ws(5,6, 234567.) | ws(6,6, 234567.);
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @  @ 27.000000  27.500000  027  27.500@    @
+®  ® 27.000000  27.500000  027  27.500®    ®
 \end{cfa}
 …
 \begin{cfa}[belowskip=0pt]
 sout | pad0( wd( 4, 27 ) ) | pad0( wd( 4,3, 27 ) ) | pad0( wd( 8,3, 27.5 ) );
 @00@27  @0@27 @00@27.500
+®00®27  ®0®27 ®00®27.500
 \end{cfa}
 \end{enumerate}
 …
 The format of numeric input values in the same as C constants without a trailing type suffix, as the input value-type is denoted by the input variable.
 For ©_Bool© type, the constants are ©true© and ©false©.
+For ©bool© type, the constants are ©true© and ©false©.
 For integral types, any number of digits, optionally preceded by a sign (©+© or ©-©), where a
 \begin{itemize}
 …
 \begin{enumerate}
 \item
+\Indexc{skip( const char * pattern )}\index{manipulator!skip@©skip©} / ©skip( unsigned int length )© / ©const char * pattern©
+The argument defines a ©pattern© or ©length©.
+The ©pattern© is composed of white-space and non-white-space characters, where \emph{any} white-space character matches 0 or more input white-space characters (hence, consecutive white-space characters in the pattern are combined), and each non-white-space character matches exactly with an input character.
+The ©length© is composed of the next $N$ characters, including the newline character.
+\Indexc{skip}( pattern )\index{manipulator!skip@©skip©}, ©skip©( length )
+The pattern is composed of white-space and non-white-space characters, where \emph{any} white-space character matches 0 or more input white-space characters (hence, consecutive white-space characters in the pattern are combined), and each non-white-space character matches exactly with an input character.
+The length is composed of the next $N$ characters, including the newline character.
 If the match successes, the input characters are discarded, and input continues with the next character.
 If the match fails, the input characters are left unread.
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+@abc   @
+@abc  @
+@xx@
 \end{cfa}
 \item
 \Indexc{wdi}©( unsigned int maximum, T & val )©\index{manipulator!wdi@©wdi©}
 For all types except ©char©, ©maximum© is the maximum number of characters read for the current operation.
+®abc   ®
+®abc  ®
+®xx®
+\end{cfa}
+\item
+\Indexc{wdi}( maximum, reference-value )\index{manipulator!wdi@©wdi©}
+For all types except ©char©, maximum is the maximum number of characters read for the current operation.
 \begin{cfa}[belowskip=0pt]
 char s[10];   int i;   double d;
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+@abcd1233.456E+2@
+®abcd1233.456E+2®
 \end{cfa}
 Note, input ©wdi© cannot be overloaded with output ©wd© because both have the same parameters but return different types.
 …
 \item
 \Indexc{ignore( T & val )}\index{manipulator!ignore@©ignore©}
+\Indexc{ignore}( reference-value )\index{manipulator!ignore@©ignore©}
 For all types, the data is read from the stream depending on the argument type but ignored, \ie it is not stored in the argument.
 \begin{cfa}[belowskip=0pt]
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @  -75.35e-4@ 25
 \end{cfa}
 \item
 \Indexc{incl( const char * scanset, char * s )}\index{manipulator!incl@©incl©}
 For the C-string type, the argument defines a ©scanset© that matches any number of characters \emph{in} the set.
 Matching characters are read into the C string and null terminated.
+®  -75.35e-4® 25
+\end{cfa}
+\item
+\Indexc{incl}( scanset, input-string )\index{manipulator!incl@©incl©}
+For C-string types, the scanset matches any number of characters \emph{in} the set.
+Matching characters are read into the C input-string and null terminated.
 \begin{cfa}[belowskip=0pt]
 char s[10];
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @bca@xyz
 \end{cfa}
 \item
 \Indexc{excl( const char * scanset, char * s )}\index{manipulator!excl@©excl©}
 For the C-string type, the argument defines a ©scanset© that matches any number of characters \emph{not in} the set.
 Non-matching characters are read into the C string and null terminated.
+®bca®xyz
+\end{cfa}
+\item
+\Indexc{excl}( scanset, input-string )\index{manipulator!excl@©excl©}
+For C-string types, the scanset matches any number of characters \emph{not in} the set.
+Non-matching characters are read into the C input-string and null terminated.
 \begin{cfa}[belowskip=0pt]
 char s[10];
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @xyz@bca
+®xyz®bca
 \end{cfa}
 \end{enumerate}
+\subsection{Concurrent Stream Access}
+When a stream is shared by multiple threads, input or output characters can be intermixed or cause failure.
+For example, if two threads execute the following:
+\begin{cfa}
+$\emph{thread\(_1\)}$ : sout | "abc " | "def ";
+$\emph{thread\(_2\)}$ : sout | "uvw " | "xyz ";
+\end{cfa}
+possible outputs are:
+\begin{cquote}
+\begin{tabular}{@{}l|l|l|l|l@{}}
+\begin{cfa}
+abc def
+uvw xyz
+\end{cfa}
+&
+\begin{cfa}
+abc uvw xyz
+def
+\end{cfa}
+&
+\begin{cfa}
+uvw abc xyz def
+\end{cfa}
+&
+\begin{cfa}
+abuvwc dexf
+yz
+\end{cfa}
+&
+\begin{cfa}
+uvw abc def
+xyz
+\end{cfa}
+\end{tabular}
+\end{cquote}
+Concurrent operations can even corrupt the internal state of the stream resulting in failure.
+As a result, some form of mutual exclusion is required for concurrent stream access.
+A coarse-grained solution is to perform all stream operations via a single thread or within a monitor providing the necessary mutual exclusion for the stream.
+A fine-grained solution is to have a lock for each stream, which is acquired and released around stream operations by each thread.
+\CFA provides a fine-grained solution where a \Index{recursive lock} is acquired and released indirectly via a manipulator ©acquire© or instantiating an \Index{RAII} type specific for the kind of stream: ©osacquire©\index{ostream@©ostream©!osacquire@©osacquire©} for output streams and ©isacquire©\index{isacquire@©isacquire©}\index{istream@©istream©!isacquire@©isacquire©} for input streams.
+The common usage is manipulator ©acquire©\index{ostream@©ostream©!acquire@©acquire©} to lock a stream during a single cascaded I/O expression, with the manipulator appearing as the first item in a cascade list, \eg:
+\begin{cfa}
+$\emph{thread\(_1\)}$ : sout | ®acquire® | "abc " | "def ";   // manipulator
+$\emph{thread\(_2\)}$ : sout | ®acquire® | "uvw " | "xyz ";
+\end{cfa}
+Now, the order of the thread execution is still non-deterministic, but the output is constrained to two possible lines in either order.
+\begin{cquote}
+\def\VRfont{\fontfamily{pcr}\upshape\selectfont}
+\begin{tabular}{@{}l|l@{}}
+\begin{cfa}
+abc def
+uvw xyz
+\end{cfa}
+&
+\begin{cfa}
+uvw xyz
+abc def
+\end{cfa}
+\end{tabular}
+\end{cquote}
+In summary, the stream lock is acquired by the ©acquire© manipulator and implicitly released at the end of the cascaded I/O expression ensuring all operations in the expression occur atomically.
+To lock a stream across multiple I/O operations, an object of type ©osacquire© or ©isacquire© is declared to implicitly acquire/release the stream lock providing mutual exclusion for the object's duration, \eg:
+\begin{cfa}
+{       // acquire sout for block duration
+        ®osacquire® acq = { sout };                             $\C{// named stream locker}$
+        sout | 1;
+        sout | ®acquire® | 2 | 3;                               $\C{// unnecessary, but ok to acquire and release again}$
+        sout | 4;
+}       // implicitly release the lock when "acq" is deallocated
+\end{cfa}
+Note, the unnecessary ©acquire© manipulator works because the recursive stream-lock can be acquired/released multiple times by the owner thread.
+Hence, calls to functions that also acquire a stream lock for their output do not result in \Index{deadlock}.
+The previous values written by threads 1 and 2 can be read in concurrently:
+\begin{cfa}
+{       // acquire sin lock for block duration
+        ®isacquire acq = { sin };®                              $\C{// named stream locker}$
+        int x, y, z, w;
+        sin | x;
+        sin | ®acquire® | y | z;                                $\C{// unnecessary, but ok to acquire and release again}$
+        sin | w;
+}       // implicitly release the lock when "acq" is deallocated
+\end{cfa}
+Again, the order of the reading threads is non-deterministic.
+Note, non-deterministic reading is rare.
+\Textbf{WARNING:} The general problem of \Index{nested locking} can occur if routines are called in an I/O sequence that block, \eg:
+\begin{cfa}
+sout | ®acquire® | "data:" | rtn( mon );        $\C{// mutex call on monitor}$
+\end{cfa}
+If the thread executing the I/O expression blocks in the monitor with the ©sout© lock, other threads writing to ©sout© also block until the thread holding the lock is unblocked and releases it.
+This scenario can lead to \Index{deadlock}, if the thread that is going to unblock the thread waiting in the monitor first writes to ©sout© (deadly embrace).
+To prevent nested locking, a simple precaution is to factor out the blocking call from the expression, \eg:
+\begin{cfa}
+int ®data® = rtn( mon );
+sout | acquire | "data:" | ®data®;
+\end{cfa}
+\Textbf{WARNING:} ©printf©\index{printf@©printf©}, ©scanf©\index{scanf@©scanf©} and their derivatives are unsafe when used with user-level threading, as in \CFA.
+These stream routines use kernel-thread locking (©futex©\index{futex@©futex©}), which block kernel threads, to prevent interleaving of I/O.
+However, the following simple example illustrates how a deadlock can occur (other complex scenarios are possible).
+Assume a single kernel thread and two user-level threads calling ©printf©.
+One user-level thread acquires the I/O lock and is time-sliced while performing ©printf©.
+The other user-level thread then starts execution, calls ©printf©, and blocks the only kernel thread because it cannot acquire the I/O lock.
+It does not help if the kernel lock is multiple acquisition, \ie, the lock owner can acquire it multiple times, because it then results in two user threads in the ©printf© critical section, corrupting the stream.
+\begin{comment}
 \section{Types}
 …
 process((int) s); // type is converted, no function is called
 \end{cfa}
+\end{comment}
 …
 In C, the integer constants 0 and 1 suffice because the integer promotion rules can convert them to any arithmetic type, and the rules for pointer expressions treat constant expressions evaluating to 0 as a special case.
 However, user-defined arithmetic types often need the equivalent of a 1 or 0 for their functions or operators, polymorphic functions often need 0 and 1 constants of a type matching their polymorphic parameters, and user-defined pointer-like types may need a null value.
 Defining special constants for a user-defined type is more efficient than defining a conversion to the type from ©_Bool©.
+Defining special constants for a user-defined type is more efficient than defining a conversion to the type from ©bool©.
 Why just 0 and 1? Why not other integers? No other integers have special status in C.
 …
 \begin{table}[hbt]
 \centering
+\input{../refrat/operidents}
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
+\begin{tabular}{@{}ll@{}}
+©?[?]©  & subscripting \impl{?[?]}                                      \\
+©?()©   & function call \impl{?()}                                      \\
+©?++©   & postfix increment \impl{?++}                          \\
+©?--©   & postfix decrement \impl{?--}                          \\
+©++?©   & prefix increment \impl{++?}                           \\
+©--?©   & prefix decrement \impl{--?}                           \\
+©*?©    & dereference \impl{*?}                                         \\
+©+?©    & unary plus \impl{+?}                                          \\
+©-?©    & arithmetic negation \impl{-?}                         \\
+©~?©    & bitwise negation \impl{~?}                            \\
+©!?©    & logical complement \impl{"!?}                         \\
+©?\?©   & exponentiation \impl{?\?}                                     \\
+©?*?©   & multiplication \impl{?*?}                                     \\
+©?/?©   & division \impl{?/?}                                           \\
+©?%?©   & remainder \impl{?%?}                                          \\
+\end{tabular}
+&
+\begin{tabular}{@{}ll@{}}
+©?+?©   & addition \impl{?+?}                                           \\
+©?-?©   & subtraction \impl{?-?}                                        \\
+©?<<?©  & left shift \impl{?<<?}                                        \\
+©?>>?©  & right shift \impl{?>>?}                                       \\
+©?<?©   & less than \impl{?<?}                                          \\
+©?<=?©  & less than or equal \impl{?<=?}                        \\
+©?>=?©  & greater than or equal \impl{?>=?}                     \\
+©?>?©   & greater than \impl{?>?}                                       \\
+©?==?©  & equality \impl{?==?}                                          \\
+©?!=?©  & inequality \impl{?"!=?}                                       \\
+©?&?©   & bitwise AND \impl{?&?}                                        \\
+©?^?©   & exclusive OR \impl{?^?}                                       \\
+©?|?©   & inclusive OR \impl{?"|?}                                      \\
+                                                                                                        \\
+                                                                                                        \\
+\end{tabular}
+&
+\begin{tabular}{@{}ll@{}}
+©?=?©   & simple assignment \impl{?=?}                          \\
+©?\=?©  & exponentiation assignment \impl{?\=?}         \\
+©?*=?©  & multiplication assignment \impl{?*=?}         \\
+©?/=?©  & division assignment \impl{?/=?}                       \\
+©?%=?©  & remainder assignment \impl{?%=?}                      \\
+©?+=?©  & addition assignment \impl{?+=?}                       \\
+©?-=?©  & subtraction assignment \impl{?-=?}            \\
+©?<<=?© & left-shift assignment \impl{?<<=?}            \\
+©?>>=?© & right-shift assignment \impl{?>>=?}           \\
+©?&=?©  & bitwise AND assignment \impl{?&=?}            \\
+©?^=?©  & exclusive OR assignment \impl{?^=?}           \\
+©?|=?©  & inclusive OR assignment \impl{?"|=?}          \\
+                                                                                                        \\
+                                                                                                        \\
+                                                                                                        \\
+\end{tabular}
+\end{tabular}
 \caption{Operator Identifiers}
 \label{opids}
 …
 For example, given
 \begin{cfa}
 auto j = @...@
+auto j = ®...®
 \end{cfa}
 and the need to write a routine to compute using ©j©
 \begin{cfa}
 void rtn( @...@ parm );
+void rtn( ®...® parm );
 rtn( j );
 \end{cfa}
 …
 \begin{figure}
 \begin{cfa}
 #include <fstream>
 #include <coroutine>
 coroutine Fibonacci {
+#include <fstream.hfa>
+#include ®<coroutine.hfa>®
+®coroutine® Fibonacci {
         int fn; $\C{// used for communication}$
 };
+void ?{}( Fibonacci * this ) {
+        this->fn = 0;
+}
+void main( Fibonacci * this ) {
+void main( Fibonacci & fib ) with( fib ) { $\C{// called on first resume}$
         int fn1, fn2; $\C{// retained between resumes}$
+        this->fn = 0; $\C{// case 0}$
+        fn1 = this->fn;
+        suspend(); $\C{// return to last resume}$
+        this->fn = 1; $\C{// case 1}$
+        fn2 = fn1;
+        fn1 = this->fn;
+        suspend(); $\C{// return to last resume}$
+        for ( ;; ) { $\C{// general case}$
+                this->fn = fn1 + fn2;
+                fn2 = fn1;
+                fn1 = this->fn;
+                suspend(); $\C{// return to last resume}$
+        } // for
+}
+int next( Fibonacci * this ) {
+        resume( this ); $\C{// transfer to last suspend}$
+        return this->fn;
+        fn = 0;  fn1 = fn; $\C{// 1st case}$
+        ®suspend;® $\C{// restart last resume}$
+        fn = 1;  fn2 = fn1;  fn1 = fn; $\C{// 2nd case}$
+        ®suspend;® $\C{// restart last resume}$
+        for () {
+                fn = fn1 + fn2;  fn2 = fn1;  fn1 = fn; $\C{// general case}$
+                ®suspend;® $\C{// restart last resume}$
+        }
+}
+int next( Fibonacci & fib ) with( fib ) {
+        ®resume( fib );® $\C{// restart last suspend}$
+        return fn;
+}
 int main() {
         Fibonacci f1, f2;
+        for ( int i = 1; i <= 10; i += 1 ) {
+                sout | next( &f1 ) | ' ' | next( &f2 );
+        } // for
+}
+\end{cfa}
+        for ( 10 ) { $\C{// print N Fibonacci values}$
+                sout | next( f1 ) | next( f2 );
+        }
+}
+\end{cfa}
+\vspace*{-5pt}
 \caption{Fibonacci Coroutine}
 \label{f:FibonacciCoroutine}
 …
 \begin{figure}
 \begin{cfa}
+#include <fstream>
+#include <kernel>
+#include <monitor>
+#include <thread>
+monitor global_t {
+        int value;
+};
+void ?{}(global_t * this) {
+        this->value = 0;
+}
+static global_t global;
+void increment3( global_t * mutex this ) {
+        this->value += 1;
+}
+void increment2( global_t * mutex this ) {
+        increment3( this );
+}
+void increment( global_t * mutex this ) {
+        increment2( this );
+}
+#include <fstream.hfa>
+#include ®<thread.hfa>®
+®monitor® AtomicCnt { int counter; };
+void ?{}( AtomicCnt & c, int init = 0 ) with(c) { counter = init; }
+int inc( AtomicCnt & ®mutex® c, int inc = 1 ) with(c) { return counter += inc; }
+int dec( AtomicCnt & ®mutex® c, int dec = 1 ) with(c) { return counter -= dec; }
+forall( ostype & | ostream( ostype ) ) { $\C{// print any stream}$
+        ostype & ?|?( ostype & os, AtomicCnt c ) { return os | c.counter; }
+        void ?|?( ostype & os, AtomicCnt c ) { (ostype &)(os | c.counter); ends( os ); }
+}
+AtomicCnt global; $\C{// shared}$
 thread MyThread {};
 void main( MyThread* this ) {
         for(int i = 0; i < 1_000_000; i++) {
                 increment( &global );
+void main( MyThread & ) {
+        for ( i; 100_000 ) {
+                inc( global );
+                dec( global );
+        }
+}
+int main(int argc, char* argv[]) {
+        processor p;
+int main() {
+        enum { Threads = 4 };
+        processor p[Threads - 1]; $\C{// + starting processor}$
+        {
                 MyThread f[4];
+                MyThread t[Threads];
+        }
         sout | global.value;
+        sout | global; $\C{// print 0}$
+}
 \end{cfa}
 \caption{Atomic-Counter Monitor}
 \caption{f:AtomicCounterMonitor}
+\label{f:AtomicCounterMonitor}
 \end{figure}
 …
 C has a number of syntax ambiguities, which are resolved by taking the longest sequence of overlapping characters that constitute a token.
 For example, the program fragment ©x+++++y© is parsed as \lstinline[showspaces=true]@x ++ ++ + y@ because operator tokens ©++© and ©+© overlap.
 Unfortunately, the longest sequence violates a constraint on increment operators, even though the parse \lstinline[showspaces=true]@x ++ + ++ y@ might yield a correct expression.
+For example, the program fragment ©x+++++y© is parsed as \lstinline[showspaces=true]{x ++ ++ + y} because operator tokens ©++© and ©+© overlap.
+Unfortunately, the longest sequence violates a constraint on increment operators, even though the parse \lstinline[showspaces=true]{x ++ + ++ y} might yield a correct expression.
 Hence, C programmers are aware that spaces have to added to disambiguate certain syntactic cases.
 …
 requiring arbitrary whitespace look-ahead for the routine-call parameter-list to disambiguate.
 However, the dereference operator \emph{must} have a parameter/argument to dereference ©*?(...)©.
 Hence, always interpreting the string ©*?()© as \lstinline[showspaces=true]@* ?()@ does not preclude any meaningful program.
+Hence, always interpreting the string ©*?()© as \lstinline[showspaces=true]{* ?()} does not preclude any meaningful program.
 The remaining cases are with the increment/decrement operators and conditional expression, \eg:
 …
 \begin{cfa}
 int i; $\C{// forward definition}$
 int *j = @&i@; $\C{// forward reference, valid in C, invalid in \CFA}$
+int *j = ®&i®; $\C{// forward reference, valid in C, invalid in \CFA}$
 int i = 0; $\C{// definition}$
 \end{cfa}
 …
 struct X { int i; struct X *next; };
 static struct X a; $\C{// forward definition}$
 static struct X b = { 0, @&a@ };$\C{// forward reference, valid in C, invalid in \CFA}$
+static struct X b = { 0, ®&a® };$\C{// forward reference, valid in C, invalid in \CFA}$
 static struct X a = { 1, &b }; $\C{// definition}$
 \end{cfa}
 …
 \item[Change:] have ©struct© introduce a scope for nested types:
 \begin{cfa}
 enum @Colour@ { R, G, B, Y, C, M };
+enum ®Colour® { R, G, B, Y, C, M };
 struct Person {
         enum @Colour@ { R, G, B };      $\C[7cm]{// nested type}$
+        enum ®Colour® { R, G, B };      $\C[7cm]{// nested type}$
         struct Face { $\C{// nested type}$
                 @Colour@ Eyes, Hair; $\C{// type defined outside (1 level)}$
+                ®Colour® Eyes, Hair; $\C{// type defined outside (1 level)}$
         };
         @.Colour@ shirt; $\C{// type defined outside (top level)}$
         @Colour@ pants; $\C{// type defined same level}$
+        ®.Colour® shirt; $\C{// type defined outside (top level)}$
+        ®Colour® pants; $\C{// type defined same level}$
         Face looks[10]; $\C{// type defined same level}$
 };
 @Colour@ c = R; $\C{// type/enum defined same level}$
 Person@.Colour@ pc = Person@.@R;$\C{// type/enum defined inside}$
 Person@.@Face pretty; $\C{// type defined inside}\CRT$
+®Colour® c = R; $\C{// type/enum defined same level}$
+Person®.Colour® pc = Person®.®R;$\C{// type/enum defined inside}$
+Person®.®Face pretty; $\C{// type defined inside}\CRT$
 \end{cfa}
 In C, the name of the nested types belongs to the same scope as the name of the outermost enclosing structure, \ie the nested types are hoisted to the scope of the outer-most type, which is not useful and confusing.
 …
 \label{s:CFAKeywords}
 \CFA introduces the following new keywords.
+\CFA introduces the following new \Index{keyword}s, which cannot be used as identifiers.
 \begin{cquote}
+\input{../refrat/keywords}
+\begin{tabular}{@{}lllllll@{}}
+\begin{tabular}{@{}l@{}}
+\Indexc{basetypeof}             \\
+\Indexc{choose}                 \\
+\Indexc{coroutine}              \\
+\Indexc{disable}                \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+\Indexc{enable}                 \\
+\Indexc{exception}              \\
+\Indexc{fallthrough}    \\
+\Indexc{fallthru}               \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+\Indexc{finally}                \\
+\Indexc{fixup}                  \\
+\Indexc{forall}                 \\
+\Indexc{generator}              \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+\Indexc{int128}                 \\
+\Indexc{monitor}                \\
+\Indexc{mutex}                  \\
+\Indexc{one_t}                  \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+\Indexc{report}                 \\
+\Indexc{suspend}                \\
+\Indexc{throw}                  \\
+\Indexc{throwResume}    \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+\Indexc{trait}                  \\
+\Indexc{try}                    \\
+\Indexc{virtual}                \\
+\Indexc{waitfor}                \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+\Indexc{when}                   \\
+\Indexc{with}                   \\
+\Indexc{zero_t}                 \\
+                                                \\
+\end{tabular}
+\end{tabular}
 \end{cquote}
+\CFA introduces the following new \Index{quasi-keyword}s, which can be used as identifiers.
+\begin{cquote}
+\begin{tabular}{@{}ll@{}}
+\begin{tabular}{@{}l@{}}
+\Indexc{catch}                  \\
+\Indexc{catchResume}    \\
+\Indexc{finally}                \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+\Indexc{fixup}                  \\
+\Indexc{or}                             \\
+\Indexc{timeout}                \\
+\end{tabular}
+\end{tabular}
+\end{cquote}
 \section{Standard Headers}
 …
 // assume ?|? operator for printing an S
 S & sp = *@new@( 3 );                                                   $\C{// call constructor after allocation}$
+S & sp = *®new®( 3 );                                                   $\C{// call constructor after allocation}$
 sout | sp.i;
 @delete@( &sp );
 S * spa = @anew@( 10, 5 );                                              $\C{// allocate array and initialize each array element}$
+®delete®( &sp );
+S * spa = ®anew®( 10, 5 );                                              $\C{// allocate array and initialize each array element}$
 for ( i; 10 ) sout | spa[i] | nonl;
 sout | nl;
 @adelete@( 10, spa );
+®adelete®( 10, spa );
 \end{cfa}
 Allocation routines ©new©/©anew© allocate a variable/array and initialize storage using the allocated type's constructor.
 …
 [ int, long double ] remquo( long double, long double );
-float div( float, float, int * );$\indexc{div}$ $\C{// alternative name for remquo}$
-double div( double, double, int * );
-long double div( long double, long double, int * );
 [ int, float ] div( float, float );
 [ int, double ] div( double, double );
 …
 long double _Complex log( long double _Complex );
+float log2( float );$\indexc{log2}$
+int log2( unsigned int );$\indexc{log2}$
+long int log2( unsigned long int );
+long long int log2( unsigned long long int )
+float log2( float );
 double log2( double );
 long double log2( long double );
 …
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+// n / align * align
+signed char floor( signed char n, signed char align );
+unsigned char floor( unsigned char n, unsigned char align );
+short int floor( short int n, short int align );
+unsigned short int floor( unsigned short int n, unsigned short int align );
+int floor( int n, int align );
+unsigned int floor( unsigned int n, unsigned int align );
+long int floor( long int n, long int align );
+unsigned long int floor( unsigned long int n, unsigned long int align );
+long long int floor( long long int n, long long int align );
+unsigned long long int floor( unsigned long long int n, unsigned long long int align );
+// (n + (align - 1)) / align
+signed char ceiling_div( signed char n, char align );
+unsigned char ceiling_div( unsigned char n, unsigned char align );
+short int ceiling_div( short int n, short int align );
+unsigned short int ceiling_div( unsigned short int n, unsigned short int align );
+int ceiling_div( int n, int align );
+unsigned int ceiling_div( unsigned int n, unsigned int align );
+long int ceiling_div( long int n, long int align );
+unsigned long int ceiling_div( unsigned long int n, unsigned long int align );
+long long int ceiling_div( long long int n, long long int align );
+unsigned long long int ceiling_div( unsigned long long int n, unsigned long long int align );
+// floor( n + (n % align != 0 ? align - 1 : 0), align )
+signed char ceiling( signed char n, signed char align );
+unsigned char ceiling( unsigned char n, unsigned char align );
+short int ceiling( short int n, short int align );
+unsigned short int ceiling( unsigned short int n, unsigned short int align );
+int ceiling( int n, int align );
+unsigned int ceiling( unsigned int n, unsigned int align );
+long int ceiling( long int n, long int align );
+unsigned long int ceiling( unsigned long int n, unsigned long int align );
+long long int ceiling( long long int n, long long int align );
+unsigned long long int ceiling( unsigned long long int n, unsigned long long int align );
 float floor( float );$\indexc{floor}$
 double floor( double );
 …
 %\subsection{\texorpdfstring{\protect\lstinline@Duration@}{Duration}}
+%\subsection{\texorpdfstring{\protect\lstinline{Duration}}{Duration}}
 \subsection{\texorpdfstring{\LstBasicStyle{Duration}}{Duration}}
 \label{s:Duration}
 …
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 struct Duration {
         int64_t tv; $\C{// nanoseconds}$
+        int64_t tn; $\C{// nanoseconds}$
 };
 void ?{}( Duration & dur );
 void ?{}( Duration & dur, zero_t );
+void ?{}( Duration & dur, timeval t )
+void ?{}( Duration & dur, timespec t )
 Duration ?=?( Duration & dur, zero_t );
+Duration ?=?( Duration & dur, timeval t )
+Duration ?=?( Duration & dur, timespec t )
 Duration +?( Duration rhs );
 …
 Duration ?%=?( Duration & lhs, Duration rhs );
 _Bool ?==?( Duration lhs, Duration rhs );
 _Bool ?!=?( Duration lhs, Duration rhs );
 _Bool ?<? ( Duration lhs, Duration rhs );
 _Bool ?<=?( Duration lhs, Duration rhs );
 _Bool ?>? ( Duration lhs, Duration rhs );
 _Bool ?>=?( Duration lhs, Duration rhs );
 _Bool ?==?( Duration lhs, zero_t );
 _Bool ?!=?( Duration lhs, zero_t );
 _Bool ?<? ( Duration lhs, zero_t );
 _Bool ?<=?( Duration lhs, zero_t );
 _Bool ?>? ( Duration lhs, zero_t );
 _Bool ?>=?( Duration lhs, zero_t );
+bool ?==?( Duration lhs, zero_t );
+bool ?!=?( Duration lhs, zero_t );
+bool ?<? ( Duration lhs, zero_t );
+bool ?<=?( Duration lhs, zero_t );
+bool ?>? ( Duration lhs, zero_t );
+bool ?>=?( Duration lhs, zero_t );
+bool ?==?( Duration lhs, Duration rhs );
+bool ?!=?( Duration lhs, Duration rhs );
+bool ?<? ( Duration lhs, Duration rhs );
+bool ?<=?( Duration lhs, Duration rhs );
+bool ?>? ( Duration lhs, Duration rhs );
+bool ?>=?( Duration lhs, Duration rhs );
 Duration abs( Duration rhs );
 …
 int64_t ?`w( Duration dur );
+double ?`dns( Duration dur );
+double ?`dus( Duration dur );
+double ?`dms( Duration dur );
+double ?`ds( Duration dur );
+double ?`dm( Duration dur );
+double ?`dh( Duration dur );
+double ?`dd( Duration dur );
+double ?`dw( Duration dur );
 Duration max( Duration lhs, Duration rhs );
 Duration min( Duration lhs, Duration rhs );
+\end{cfa}
+%\subsection{\texorpdfstring{\protect\lstinline@\timeval@}{timeval}}
+forall( ostype & | ostream( ostype ) ) ostype & ?|?( ostype & os, Duration dur );
+\end{cfa}
+%\subsection{\texorpdfstring{\protect\lstinline{timeval}}{timeval}}
 \subsection{\texorpdfstring{\LstBasicStyle{timeval}}{timeval}}
 \label{s:timeval}
 …
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 void ?{}( timeval & t );
+void ?{}( timeval & t, zero_t );
 void ?{}( timeval & t, time_t sec, suseconds_t usec );
 void ?{}( timeval & t, time_t sec );
-void ?{}( timeval & t, zero_t );
 void ?{}( timeval & t, Time time );
 …
 timeval ?+?( timeval & lhs, timeval rhs );
 timeval ?-?( timeval & lhs, timeval rhs );
 _Bool ?==?( timeval lhs, timeval rhs );
 _Bool ?!=?( timeval lhs, timeval rhs );
 \end{cfa}
 %\subsection{\texorpdfstring{\protect\lstinline@timespec@}{timespec}}
+bool ?==?( timeval lhs, timeval rhs );
+bool ?!=?( timeval lhs, timeval rhs );
+\end{cfa}
+%\subsection{\texorpdfstring{\protect\lstinline{timespec}}{timespec}}
 \subsection{\texorpdfstring{\LstBasicStyle{timespec}}{timespec}}
 \label{s:timespec}
 …
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 void ?{}( timespec & t );
+void ?{}( timespec & t, zero_t );
 void ?{}( timespec & t, time_t sec, __syscall_slong_t nsec );
 void ?{}( timespec & t, time_t sec );
-void ?{}( timespec & t, zero_t );
 void ?{}( timespec & t, Time time );
 …
 timespec ?+?( timespec & lhs, timespec rhs );
 timespec ?-?( timespec & lhs, timespec rhs );
 _Bool ?==?( timespec lhs, timespec rhs );
 _Bool ?!=?( timespec lhs, timespec rhs );
 \end{cfa}
 %\subsection{\texorpdfstring{\protect\lstinline@itimerval@}{itimerval}}
+bool ?==?( timespec lhs, timespec rhs );
+bool ?!=?( timespec lhs, timespec rhs );
+\end{cfa}
+%\subsection{\texorpdfstring{\protect\lstinline{itimerval}}{itimerval}}
 \subsection{\texorpdfstring{\LstBasicStyle{itimerval}}{itimerval}}
 \label{s:itimerval}
 …
 %\subsection{\texorpdfstring{\protect\lstinline@Time@}{Time}}
+%\subsection{\texorpdfstring{\protect\lstinline{Time}}{Time}}
 \subsection{\texorpdfstring{\LstBasicStyle{Time}}{Time}}
 \label{s:Time}
 …
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 struct Time {
         uint64_t tv; $\C{// nanoseconds since UNIX epoch}$
+        uint64_t tn; $\C{// nanoseconds since UNIX epoch}$
 };
 void ?{}( Time & time );
 void ?{}( Time & time, zero_t );
+void ?{}( Time & time, timeval t );
+void ?{}( Time & time, timespec t );
 Time ?=?( Time & time, zero_t );
-void ?{}( Time & time, timeval t );
 Time ?=?( Time & time, timeval t );
-void ?{}( Time & time, timespec t );
 Time ?=?( Time & time, timespec t );
 …
 Time ?-?( Time lhs, Duration rhs );
 Time ?-=?( Time & lhs, Duration rhs );
+_Bool ?==?( Time lhs, Time rhs );
+_Bool ?!=?( Time lhs, Time rhs );
+_Bool ?<?( Time lhs, Time rhs );
+_Bool ?<=?( Time lhs, Time rhs );
+_Bool ?>?( Time lhs, Time rhs );
+_Bool ?>=?( Time lhs, Time rhs );
+bool ?==?( Time lhs, Time rhs );
+bool ?!=?( Time lhs, Time rhs );
+bool ?<?( Time lhs, Time rhs );
+bool ?<=?( Time lhs, Time rhs );
+bool ?>?( Time lhs, Time rhs );
+bool ?>=?( Time lhs, Time rhs );
+int64_t ?`ns( Time t );
 char * yy_mm_dd( Time time, char * buf );
+char * ?`ymd( Time time, char * buf ) { // short form
+        return yy_mm_dd( time, buf );
+} // ymd
+char * ?`ymd( Time time, char * buf ); // short form
 char * mm_dd_yy( Time time, char * buf );
+char * ?`mdy( Time time, char * buf ) { // short form
+        return mm_dd_yy( time, buf );
+} // mdy
+char * ?`mdy( Time time, char * buf ); // short form
 char * dd_mm_yy( Time time, char * buf );
+char * ?`dmy( Time time, char * buf ) { // short form
+        return dd_mm_yy( time, buf );;
+} // dmy
+char * ?`dmy( Time time, char * buf ); // short form
 size_t strftime( char * buf, size_t size, const char * fmt, Time time );
+forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
+forall( ostype & | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
 \end{cfa}
 …
 %\subsection{\texorpdfstring{\protect\lstinline@Clock@}{Clock}}
+%\subsection{\texorpdfstring{\protect\lstinline{Clock}}{Clock}}
 \subsection{\texorpdfstring{\LstBasicStyle{Clock}}{Clock}}
 \label{s:Clock}
 …
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+struct Clock {
+        Duration offset; $\C{// for virtual clock: contains offset from real-time}$
+        int clocktype; $\C{// implementation only -1 (virtual), CLOCK\_REALTIME}$
+struct Clock { $\C{// virtual clock}$
+        Duration offset; $\C{// offset from computer real-time}$
 };
+void resetClock( Clock & clk );
+void resetClock( Clock & clk, Duration adj );
+void ?{}( Clock & clk );
+void ?{}( Clock & clk, Duration adj );
+Duration getResNsec(); $\C{// with nanoseconds}$
+Duration getRes(); $\C{// without nanoseconds}$
+Time getTimeNsec(); $\C{// with nanoseconds}$
+Time getTime(); $\C{// without nanoseconds}$
+Time getTime( Clock & clk );
+Time ?()( Clock & clk );
+timeval getTime( Clock & clk );
+tm getTime( Clock & clk );
+void ?{}( Clock & clk ); $\C{// create no offset}$
+void ?{}( Clock & clk, Duration adj ); $\C{// create with offset}$
+void reset( Clock & clk, Duration adj ); $\C{// change offset}$
+Duration resolutionHi(); $\C{// clock resolution in nanoseconds (fine)}$
+Duration resolution(); $\C{// clock resolution without nanoseconds (coarse)}$
+Time timeHiRes(); $\C{// real time with nanoseconds}$
+Time time(); $\C{// real time without nanoseconds}$
+Time time( Clock & clk ); $\C{// real time for given clock}$
+Time ?()( Clock & clk ); $\C{//\ \ \ \ alternative syntax}$
+timeval time( Clock & clk ); $\C{// convert to C time format}$
+tm time( Clock & clk );
+Duration processor(); $\C{// non-monotonic duration of kernel thread}$
+Duration program(); $\C{// non-monotonic duration of program CPU}$
+Duration boot(); $\C{// monotonic duration since computer boot}$
 \end{cfa}
 …
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype * os, Int mp );
 \end{cfa}
+The following factorial programs contrast using GMP with the \CFA and C interfaces, where the output from these programs appears in \VRef[Figure]{f:MultiPrecisionFactorials}.
+\VRef[Figure]{f:MultiPrecisionFactorials} shows \CFA and C factorial programs using the GMP interfaces.
 (Compile with flag \Indexc{-lgmp} to link with the GMP library.)
+\begin{figure}
 \begin{cquote}
 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}}
 \multicolumn{1}{c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}}    & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}      \\
+\multicolumn{1}{@{}c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}@{}}   \\
 \hline
 \begin{cfa}
 …
         sout | 0 | fact;
         for ( unsigned int i = 1; i <= 40; i += 1 ) {
+        for ( i; 40 ) {
                 fact *= i;
                 sout | i | fact;
 …
 #include <gmp.h>$\indexc{gmp.h}$
 int main( void ) {
         @gmp_printf@( "Factorial Numbers\n" );
         @mpz_t@ fact;
         @mpz_init_set_ui@( fact, 1 );
         @gmp_printf@( "%d %Zd\n", 0, fact );
+        ®gmp_printf®( "Factorial Numbers\n" );
+        ®mpz_t® fact;
+        ®mpz_init_set_ui®( fact, 1 );
+        ®gmp_printf®( "%d %Zd\n", 0, fact );
         for ( unsigned int i = 1; i <= 40; i += 1 ) {
                 @mpz_mul_ui@( fact, fact, i );
                 @gmp_printf@( "%d %Zd\n", i, fact );
+                ®mpz_mul_ui®( fact, fact, i );
+                ®gmp_printf®( "%d %Zd\n", i, fact );
+        }
+}
 …
 \end{tabular}
 \end{cquote}
+\begin{figure}
+\small
 \begin{cfa}
 Factorial Numbers

Context Navigation

Legend:

doc/LaTeXmacros/lstlang.sty

doc/bibliography/pl.bib

doc/theses/andrew_beach_MMath/Makefile

doc/theses/andrew_beach_MMath/existing.tex

doc/theses/andrew_beach_MMath/features.tex

doc/theses/andrew_beach_MMath/future.tex

doc/theses/andrew_beach_MMath/implement.tex

doc/theses/andrew_beach_MMath/uw-ethesis.tex

doc/theses/mubeen_zulfiqar_MMath/uw-ethesis.bib

doc/theses/thierry_delisle_PhD/code/readyQ_proto/links.hpp

doc/theses/thierry_delisle_PhD/code/readyQ_proto/processor_list.hpp

doc/theses/thierry_delisle_PhD/code/readyQ_proto/processor_list_good.cpp

doc/theses/thierry_delisle_PhD/code/readyQ_proto/randbit.cpp

doc/theses/thierry_delisle_PhD/code/readyQ_proto/relaxed_list.cpp

doc/theses/thierry_delisle_PhD/code/readyQ_proto/snzi-packed.hpp

doc/theses/thierry_delisle_PhD/code/readyQ_proto/snzi.hpp

doc/theses/thierry_delisle_PhD/code/readyQ_proto/utils.hpp

doc/theses/thierry_delisle_PhD/code/readyQ_proto/work_stealing.hpp

doc/user/figures/Cdecl.fig

doc/user/user.tex

Download in other formats: