Changeset bae0d35

INSTALL

-              r82f4063
+              rbae0d35
 g++ version >= 4.6, bison and flex.  On systems where GNU Make is the default
 make, the system is built by entering the commands:
+For devs using the root git:
+  ./autogen.sh
+        ./configure
+        make
+        make install
+For users using the distributed tarball:
         ./configure

Jenkins/FullBuild

-              r82f4063
+              rbae0d35
                                 parallel (
+                                        gcc_8_x86_new: { trigger_build( 'gcc-8',   'x86', true  ) },
+                                        gcc_7_x86_new: { trigger_build( 'gcc-7',   'x86', true  ) },
+                                        gcc_6_x86_new: { trigger_build( 'gcc-6',   'x86', true  ) },
+                                        gcc_9_x64_new: { trigger_build( 'gcc-9',   'x64', true  ) },
+                                        gcc_8_x64_new: { trigger_build( 'gcc-8',   'x64', true  ) },
+                                        gcc_7_x64_new: { trigger_build( 'gcc-7',   'x64', true  ) },
+                                        gcc_6_x64_new: { trigger_build( 'gcc-6',   'x64', true  ) },
+                                        gcc_5_x64_new: { trigger_build( 'gcc-5',   'x64', true  ) },
+                                        clang_x64_new: { trigger_build( 'clang',   'x64', true  ) },
+                                        clang_x64_old: { trigger_build( 'clang',   'x64', false ) },
+                                        gcc_8_x86_new: { trigger_build( 'gcc-8',   'x86' ) },
+                                        gcc_7_x86_new: { trigger_build( 'gcc-7',   'x86' ) },
+                                        gcc_6_x86_new: { trigger_build( 'gcc-6',   'x86' ) },
+                                        gcc_9_x64_new: { trigger_build( 'gcc-9',   'x64' ) },
+                                        gcc_8_x64_new: { trigger_build( 'gcc-8',   'x64' ) },
+                                        gcc_7_x64_new: { trigger_build( 'gcc-7',   'x64' ) },
+                                        gcc_6_x64_new: { trigger_build( 'gcc-6',   'x64' ) },
+                                        gcc_5_x64_new: { trigger_build( 'gcc-5',   'x64' ) },
+                                        clang_x64_new: { trigger_build( 'clang',   'x64' ) },
+                                )
+                        }
 …
                         stage('Package') {
                                 trigger_dist( commitId, currentBuild.number.toString() )
+                        }
+                        stage('Promote') {
+                                trigger_prom()
+                        }
+                }
 …
 //===========================================================================================================
 def trigger_build(String cc, String arch, boolean new_ast) {
+def trigger_build(String cc, String arch) {
         // Randomly delay the builds by a random amount to avoid hitting the SC server to hard
         sleep(time: 5 * Math.random(), unit:"MINUTES")
 …
                         [$class: 'BooleanParameterValue',               \
                           name: 'NewAST',                               \
                           value: new_ast],                              \
+                          value: true],                                         \
                         [$class: 'BooleanParameterValue',               \
                           name: 'RunAllTests',                          \
 …
+}
+def trigger_prom() {
+        def result = build job: 'Cforall_Promote_Ref', propagate: false
+        echo(result.result)
+        if(result.result != 'SUCCESS') {
+                sh("wget -q -O - https://cforall.uwaterloo.ca/jenkins/job/Cforall_Promote_Ref/${result.number}/consoleText")
+                error(result.result)
+        }
+}
 //===========================================================================================================
 //Routine responsible of sending the email notification once the build is completed

Jenkinsfile

-              r82f4063
+              rbae0d35
                                 BuildDir  = pwd tmp: true
                                 SrcDir    = pwd tmp: false
+                                currentBuild.description = "${currentBuild.description} on ${env.NODE_NAME}"
                                 Tools.Clean()
 …
                 echo "Archiving core dumps"
                 dir (BuildDir) {
+                        archiveArtifacts artifacts: "tests/crashes/**/*,lib/**/lib*.so*", fingerprint: true
+                        def exists = fileExists 'tests/crashes'
+                        if( exists ) {
+                                sh """${SrcDir}/tools/jenkins/archive-gen.sh"""
+                                archiveArtifacts artifacts: "tests/crashes/**/*,lib/**/lib*.so*,setup.sh", fingerprint: true
+                        }
+                }
                 throw err

doc/LaTeXmacros/common.sty

-              r82f4063
+              rbae0d35
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Sat May  8 08:48:35 2021
 %% Update Count     : 550
+%% Last Modified On : Mon May 31 09:08:37 2021
+%% Update Count     : 565
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \usepackage{xspace}
 \newcommand{\CFAIcon}{\textsf{C}\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}} % Cforall icon
+\newcommand{\CFAIcon}{\textsf{C\raisebox{\depth}{\rotatebox{180}A}}} % Cforall icon
 \newcommand{\CFA}{\protect\CFAIcon\xspace}                              % CFA symbolic name
 \newcommand{\CFL}{\textrm{Cforall}\xspace}                              % Cforall non-icon name
 …
 \setlength{\parindentlnth}{\parindent}
 \usepackage{pslatex}                                    % reduce size of san serif font
 \usepackage{relsize}                                    % must be after change to small or selects old size
+\usepackage{pslatex}                                                                    % reduce size of san serif font
+\usepackage{relsize}                                                                    % must be after change to small or selects old size
 \usepackage{rotating}
+\usepackage{calc}                                                                               % latex arithmetic
 % reduce size of chapter/section titles
 …
 \newcommand{\CheckPeriod}{\@ifnextchar{.}{}{.\xspace}}
-\@ifundefined{eg}{
 \newcommand{\EG}{\abbrevFont{e}.\abbrevFont{g}.}
 \newcommand{\eg}{\EG\CheckCommaColon}
+}{}%
+\@ifundefined{ie}{
 \newcommand{\IE}{\abbrevFont{i}.\abbrevFont{e}.}
 \newcommand{\ie}{\IE\CheckCommaColon}
+}{}%
+\@ifundefined{etc}{
 \newcommand{\ETC}{\abbrevFont{etc}}
 \newcommand{\etc}{\ETC\CheckPeriod}
+}{}%
+\@ifundefined{etal}{
 \newcommand{\ETAL}{\abbrevFont{et}~\abbrevFont{al}}
 \newcommand{\etal}{\ETAL\CheckPeriod}
+}{}%
+\@ifundefined{viz}{
 \newcommand{\VIZ}{\abbrevFont{viz}}
 \newcommand{\viz}{\VIZ\CheckPeriod}
-}{}%
 \newenvironment{cquote}{%
 …
 \usepackage{listings}                                                                   % format program code
 \usepackage{lstlang}
-\usepackage{calc}                                                                               % latex arithmetic
 \newcommand{\LstBasicStyle}[1]{{\lst@basicstyle{#1}}}
 …
 numberstyle=\footnotesize\sf,                   % numbering style
 % replace/adjust listing characters that look bad in sanserif
+literate={-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.75ex}{0.1ex}}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1
+        {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
+        {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {->}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex\textgreater}2,
+literate=
+  {-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.75ex}{0.1ex}}}}1
+  {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1
+  {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1
+  {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
+  {<-}{$\leftarrow$}2
+  {=>}{$\Rightarrow$}2
+  {->}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex\textgreater}2,
+defaultdialect={CFA},
 }% lstset
 }% CFAStyle
 …
 }{}
 % inline code @...@ (at symbol)
+\makeatother
 \lstMakeShortInline@                                    % single-character for \lstinline
+\makeatletter
 \fi%

doc/LaTeXmacros/common.tex

-              r82f4063
+              rbae0d35
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Sat May  8 08:48:37 2021
 %% Update Count     : 540
+%% Last Modified On : Mon May 31 09:10:49 2021
+%% Update Count     : 546
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \usepackage{xspace}
 \newcommand{\CFAIcon}{\textsf{C}\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}} % Cforall icon
+\newcommand{\CFAIcon}{\textsf{C\raisebox{\depth}{\rotatebox{180}A}}} % Cforall icon
 \newcommand{\CFA}{\protect\CFAIcon\xspace}                              % CFA symbolic name
 \newcommand{\CFL}{\textrm{Cforall}\xspace}                              % Cforall non-icon name
 …
 \setlength{\parindentlnth}{\parindent}
 \usepackage{pslatex}                                    % reduce size of san serif font
 \usepackage{relsize}                                    % must be after change to small or selects old size
+\usepackage{pslatex}                                                                    % reduce size of san serif font
+\usepackage{relsize}                                                                    % must be after change to small or selects old size
 \usepackage{rotating}
+\usepackage{calc}                                                                               % latex arithmetic
 % reduce size of chapter/section titles
 …
 \newcommand{\CheckPeriod}{\@ifnextchar{.}{}{.\xspace}}
-\@ifundefined{eg}{
 \newcommand{\EG}{\abbrevFont{e}.\abbrevFont{g}.}
 \newcommand{\eg}{\EG\CheckCommaColon}
+}{}%
+\@ifundefined{ie}{
 \newcommand{\IE}{\abbrevFont{i}.\abbrevFont{e}.}
 \newcommand{\ie}{\IE\CheckCommaColon}
+}{}%
+\@ifundefined{etc}{
 \newcommand{\ETC}{\abbrevFont{etc}}
 \newcommand{\etc}{\ETC\CheckPeriod}
+}{}%
+\@ifundefined{etal}{
 \newcommand{\ETAL}{\abbrevFont{et}~\abbrevFont{al}}
 \newcommand{\etal}{\ETAL\CheckPeriod}
+}{}%
+\@ifundefined{viz}{
 \newcommand{\VIZ}{\abbrevFont{viz}}
 \newcommand{\viz}{\VIZ\CheckPeriod}
+}{}%
 \makeatother
 …
 \usepackage{listings}                                                                   % format program code
 \usepackage{lstlang}
-\usepackage{calc}                                                                               % latex arithmetic
 \makeatletter
 …
 numberstyle=\footnotesize\sf,                   % numbering style
 % replace/adjust listing characters that look bad in sanserif
+literate={-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.75ex}{0.1ex}}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1
+        {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
+        {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {->}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex\textgreater}2,
+literate=
+  {-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.75ex}{0.1ex}}}}1
+  {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1
+  {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1
+  {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
+  {<-}{$\leftarrow$}2
+  {=>}{$\Rightarrow$}2
+  {->}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex\textgreater}2,
+defaultdialect={CFA},
 }% lstset
 }% CFAStyle

doc/LaTeXmacros/lstlang.sty

-              r82f4063
+              rbae0d35
 %% Created On       : Sat May 13 16:34:42 2017
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Wed Feb 17 09:21:15 2021
 %% Update Count     : 27
+%% Last Modified On : Mon May 31 08:20:41 2021
+%% Update Count     : 28
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \lstdefinelanguage{uC++}[ANSI]{C++}{
         morekeywords={
                 _Accept, _AcceptReturn, _AcceptWait, _Actor, _At, _CatchResume, _Cormonitor, _Coroutine, _Disable,
                 _Else, _Enable, _Event, _Finally, _Monitor, _Mutex, _Nomutex, _PeriodicTask, _RealTimeTask,
                 _Resume, _Select, _SporadicTask, _Task, _Timeout, _When, _With, _Throw},
+                _Accept, _AcceptReturn, _AcceptWait, _Actor, _At, _Catch, _CatchResume, _CorActor, _Cormonitor, _Coroutine,
+                _Disable, _Else, _Enable, _Event, _Finally, _Monitor, _Mutex, _Nomutex, _PeriodicTask, _RealTimeTask,
+                _Resume, _ResumeTop, _Select, _SporadicTask, _Task, _Timeout, _When, _With, _Throw},
+}

doc/theses/andrew_beach_MMath/existing.tex

-              r82f4063
+              rbae0d35
 \chapter{\CFA Existing Features}
+\CFA (C-for-all)~\cite{Cforall} is an open-source project extending ISO C with
+\label{c:existing}
+\CFA is an open-source project extending ISO C with
 modern safety and productivity features, while still ensuring backwards
 compatibility with C and its programmers.  \CFA is designed to have an
 …
 existing C code-base allowing programmers to learn \CFA on an as-needed basis.
 Only those \CFA features pertinent to this thesis are discussed.  Many of the
+Only those \CFA features pertaining to this thesis are discussed.  Many of the
 \CFA syntactic and semantic features used in the thesis should be fairly
 obvious to the reader.
 …
 // name mangling on by default
 int i; // _X1ii_1
 extern "C" {  // disables name mangling
+@extern "C"@ {  // disables name mangling
         int j; // j
         extern "Cforall" {  // enables name mangling
+        @extern "Cforall"@ {  // enables name mangling
                 int k; // _X1ki_1
+        }
 …
 \section{Reference Type}
+\CFA adds a rebindable reference type to C, but more expressive than the \Cpp
+reference.  Multi-level references are allowed and act like auto-dereferenced
+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 using the address-of operator (@&@), which converts the
+reference to a pointer.
+\CFA adds a reference type to C as an auto-dereferencing pointer.
+They work very similarly to pointers.
+Reference-types are written the same way as a pointer-type but each
+asterisk (@*@) is replaced with a ampersand (@&@);
+this includes cv-qualifiers and multiple levels of reference, \eg:
+\begin{minipage}{0,5\textwidth}
+With references:
 \begin{cfa}
 int i, j;
+int & ri = i, && rri = ri;
+rri = 3;  // auto-dereference assign to i
+&ri = &j; // rebindable
+ri = 5;   // assign to j
+\end{cfa}
+\section{Constructors and Destructors}
+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
+allowed in \Cpp for constructors).
+int & ri = i;
+int && rri = ri;
+rri = 3;
+&ri = &j; // reference assignment
+ri = 5;
+\end{cfa}
+\end{minipage}
+\begin{minipage}{0,5\textwidth}
+With pointers:
+\begin{cfa}
+int i, j;
+int * pi = &i
+int ** ppi = &pi;
+**ppi = 3;
+pi = &j; // pointer assignment
+*pi = 5;
+\end{cfa}
+\end{minipage}
+References are intended for cases where you would want to use pointers but would
+be dereferencing them (almost) every usage.
+In most cases a reference can just be thought of as a pointer that
+automatically puts a dereference in front of each of its uses (per-level of
+reference).
+The address-of operator (@&@) acts as an escape and removes one of the
+automatic dereference operations.
+Mutable references may be assigned by converting them to a pointer
+with a @&@ and then assigning a pointer to them, as in @&ri = &j;@ above.
+\section{Operators}
 In general, operator names in \CFA are constructed by bracketing an operator
 …
 (such as @++?@) and post-fix operations (@?++@).
+The special name for a constructor is @?{}@, which comes from the
+initialization syntax in C. That initialation syntax is also the operator
+form. \CFA will generate a constructor call each time a variable is declared,
+passing the initialization arguments to the constructort.
+\begin{cfa}
+struct Example { ... };
+void ?{}(Example & this) { ... }
+{
+        Example a;
+        Example b = {};
+}
+void ?{}(Example & this, char first, int num) { ... }
+{
+        Example c = {'a', 2};
+}
+\end{cfa}
+Both @a@ and @b@ will be initalized with the first constructor (there is no
+general way to skip initialation) while @c@ will be initalized with the
+second.
+An operator name may describe any function signature (it is just a name) but
+only certain signatures may be called in operator form.
+\begin{cfa}
+int ?+?( int i, int j, int k ) { return i + j + k; }
+{
+        sout | ?+?( 3, 4, 5 ); // no infix form
+}
+\end{cfa}
+Some ``near-misses" for unary/binary operator prototypes generate warnings.
+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
+allowed in \Cpp for constructors).
+The special name for a constructor is @?{}@, where the name @{}@ comes from the
+initialization syntax in C, \eg @Structure s = {...}@.
+% That initialization syntax is also the operator form.
+\CFA generates a constructor call each time a variable is declared,
+passing the initialization arguments to the constructor.
+\begin{cfa}
+struct Structure { ... };
+void ?{}(Structure & this) { ... }
+{
+        Structure a;
+        Structure b = {};
+}
+void ?{}(Structure & this, char first, int num) { ... }
+{
+        Structure c = {'a', 2};
+}
+\end{cfa}
+Both @a@ and @b@ are initialized with the first constructor,
+while @c@ is initialized with the second.
+Currently, there is no general way to skip initialization.
 % I don't like the \^{} symbol but $^\wedge$ isn't better.
 Similarly destructors use the special name @^?{}@ (the @^@ has no special
 meaning). They can be called explicatly as well but normally they are
 implicitly called on a variable when it goes out of scope.
 \begin{cfa}
 void ^?{}(Example & this) { ... }
+{
     Example d;
+Similarly, destructors use the special name @^?{}@ (the @^@ has no special
+meaning).  Normally, they are implicitly called on a variable when it goes out
+of scope but they can be called explicitly as well.
+\begin{cfa}
+void ^?{}(Structure & this) { ... }
+{
+        Structure d;
 } // <- implicit destructor call
 \end{cfa}
+No operator name is restricted in what function signatures they may be bound
+to although most of the forms cannot be called in operator form. Some
+``near-misses" will generate warnings.
+Whenever a type is defined, \CFA will create a default zero-argument
+Whenever a type is defined, \CFA creates a default zero-argument
 constructor, a copy constructor, a series of argument-per-field constructors
 and a destructor. All user constructors are defined after this.
 …
 char capital_a = identity( 'A' );
 \end{cfa}
 Each use of a polymorphic declaration will resolve its polymorphic parameters
+Each use of a polymorphic declaration resolves its polymorphic parameters
 (in this case, just @T@) to concrete types (@int@ in the first use and @char@
 in the second).
 …
 To allow a polymorphic function to be separately compiled, the type @T@ must be
 constrained by the operations used on @T@ in the function body. The @forall@
 clauses is augmented with a list of polymorphic variables (local type names)
+clause is augmented with a list of polymorphic variables (local type names)
 and assertions (constraints), which represent the required operations on those
 types used in a function, \eg:
 \begin{cfa}
 forall( T | { void do_once(T); })
+forall( T | { void do_once(T); } )
 void do_twice(T value) {
         do_once(value);
 …
 void do_once(double y) { ... }
 int quadruple(int x) {
+        void do_once(int y) { y = y * 2; }
+        do_twice(x);
+        void do_once(int y) { y = y * 2; } // replace global do_once
+        do_twice(x); // use local do_once
+        do_twice(x + 1.5); // use global do_once
         return x;
+}
 \end{cfa}
 Specifically, the complier deduces that @do_twice@'s T is an integer from the
 argument @x@. It then looks for the most specific definition matching the
+argument @x@. It then looks for the most \emph{specific} definition matching the
 assertion, which is the nested integral @do_once@ defined within the
 function. The matched assertion function is then passed as a function pointer
 to @do_twice@ and called within it.
 The global definition of @do_once@ is ignored.
+to @do_twice@ and called within it.  The global definition of @do_once@ is used
+for the second call because the float-point argument is a better match.
 To avoid typing long lists of assertions, constraints can be collect into
 …
 Each coroutine has a @main@ function, which takes a reference to a coroutine
 object and returns @void@.
 \begin{cfa}
+\begin{cfa}[numbers=left]
 void main(CountUp & this) {
     for (unsigned int next = 0 ; true ; ++next) {
+        for (unsigned int next = 0 ; true ; ++next) {
                 next = up;
                 suspend;$\label{suspend}$

doc/theses/andrew_beach_MMath/features.tex

-              r82f4063
+              rbae0d35
 \chapter{Exception Features}
+\label{c:features}
 This chapter covers the design and user interface of the \CFA
+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.
+EHM, % or exception system.
+and begins with a general overview of EHMs. It is not a strict
+definition of all EHMs nor an exhaustive list of all possible features.
+However it does cover the most common structures 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}
+\section{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
+These are the two parts that the user writes and may
 be the only two pieces of the EHM that have any syntax in the language.
 \subparagraph{Raise}
+\paragraph{Raise}
 The raise is the starting point for exception handling. It marks the beginning
 of exception handling by raising an excepion, which passes it to
+of exception handling by raising an exception, which passes it to
 the EHM.
 Some well known examples include the @throw@ statements of \Cpp and Java and
 the \code{Python}{raise} statement from Python. In real systems a raise may
 preform some other work (such as memory management) but for the
+the \code{Python}{raise} statement from Python. A raise may
+perform some other work (such as memory management) but for the
 purposes of this overview that can be ignored.
 \subparagraph{Handle}
+\paragraph{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
+region of code they guard, and an exception label/condition that matches
 certain exceptions.
 Only raises inside the covered region and raising exceptions that match the
+Only raises inside the guarded 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".
+Different EHMs have different rules to pick a handler,
+if multiple 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
+also show another common feature of handlers, they are grouped by the guarded
 region.
 \paragraph{Propagation}
+\section{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
+EHM: finding and setting up the handler. The propagation 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}
+matching against the handler, and installing the handler.
+\paragraph{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
+thrown as it looks for handlers that have the raise site in their guarded
 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}
+This search includes handlers in the current function, as well as any in callers
+on the stack that have the function call in their guarded region.
+\paragraph{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
+label defines a condition that is used with the exception to decide 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
+In languages where the first match is used, this step is intertwined with
+searching: a match check is performed immediately after the search finds
 a possible handler.
 \subparagraph{Installing}
+\section{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
 …
 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}
+If a matching handler is not guarantied to be found, the EHM needs a
+different course of action for the case where no handler matches.
+This situation only occurs with unchecked exceptions as checked exceptions
+(such as in Java) can make the guarantee.
+This unhandled action can abort the program or install a very general handler.
+\paragraph{Hierarchy}
 A common way to organize exceptions is in a hierarchical structure.
 This is especially true in object-orientated languages where the
+This organization is often used in object-orientated languages where the
 exception hierarchy is a natural extension of the object hierarchy.
 …
 The EHM can return control to many different places,
 the most common are after the handler definition and after the raise.
+the most common are after the handler definition (termination) and after the raise (resumption).
 \paragraph{Communication}
 For effective exception handling, additional information is often passed
 from the raise to the handler.
+from the raise to the handler and back again.
 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.
+A common communication method is putting fields into the exception instance and giving the
+handler access to them. References in the exception instance can push data back to the raise.
 \section{Virtuals}
 Virtual types and casts are not part of \CFA's EHM nor are they required for
 any EHM.
 However the \CFA uses a hierarchy built with the virtual system as the basis
 for exceptions and exception matching.
 The virtual system would have ideally been part of \CFA before the work
+However, one of the best ways to support an exception hierarchy is via a virtual system
+among exceptions and used for exception matching.
+Ideally, the virtual system would have been part of \CFA before the work
 on exception handling began, but unfortunately it was not.
 Because of this only the features and framework needed for the EHM were
+Therefore, only the features and framework needed for the EHM were
 designed and implemented. Other features were considered to ensure that
 the structure could accomidate other desirable features but they were not
+the structure could accommodate other desirable features in the future but they were not
 implemented.
 The rest of this section will only discuss the finalized portion of the
 virtual system.
+The rest of this section discusses the implemented subset of the
+virtual-system design.
 The virtual system supports multiple ``trees" of types. Each tree is
 …
 % 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.
+% A type's decedents are its children and its children's decedents.
 Every virtual type also has a list of virtual members. Children inherit
 …
 It is important to note that these are virtual members, not virtual methods
 of object-orientated programming, and can be of any type.
+\PAB{I do not understand these sentences. Can you add an example? $\Rightarrow$
 \CFA still supports virtual methods as a special case of virtual members.
 Function pointers that take a pointer to the virtual type will be modified
+Function pointers that take a pointer to the virtual type are modified
 with each level of inheritance so that refers to the new type.
 This means an object can always be passed to a function in its virtual table
 as if it were a method.
+as if it were a method.}
 Each virtual type has a unique id.
 This unique id and all the virtual members are combined
+This 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.
+\PAB{God forbid, maybe you need a UML diagram to relate these entities.}
 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
+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
+In \CFA, types do not encapsulate any behaviour. Traits are local and
+types can begin to satisfy a trait, stop satisfying a trait or satisfy 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
+In this sense, they are ``open" as they can change at any time. This capability means it
+is impossible to pick a single set of functions that represent 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
+type. A user can define virtual tables that are filled in at their
+declaration and given a name. Anywhere that name is visible, even if
+defined locally inside a function (although that means it does not have a
 static lifetime), it can be used.
 Specifically, a virtual type is ``bound" to a virtual table which
+Specifically, a virtual type is ``bound" to a virtual table that
 sets the virtual members for that object. The virtual members can be accessed
 through the object.
+\PAB{The above explanation is very good!}
 While much of the virtual infrastructure is created, it is currently only used
 internally for exception handling. The only user-level feature is the virtual
 cast, which is the same as the \Cpp \code{C++}{dynamic_cast}.
+cast
 \label{p:VirtualCast}
 \begin{cfa}
 (virtual TYPE)EXPRESSION
 \end{cfa}
+which is the same as the \Cpp \code{C++}{dynamic_cast}.
 Note, the syntax and semantics matches a C-cast, rather than the function-like
 \Cpp syntax for special casts. Both the type of @EXPRESSION@ and @TYPE@ must be
 …
 \end{cfa}
 The trait is defined over two types, the exception type and the virtual table
 type. Each exception type should have but a single virtual table type.
 Now there are no actual assertions in this trait because the trait system
 actually can't express them (adding such assertions would be part of
+type. Each exception type should have a single virtual table type.
+There are no actual assertions in this trait because currently the trait system
+cannot express them (adding such assertions would be part of
 completing the virtual system). The imaginary assertions would probably come
 from a trait defined by the virtual system, and state that the exception type
 is a virtual type, is a decendent of @exception_t@ (the base exception type)
+is a virtual type, is a descendent of @exception_t@ (the base exception type)
 and note its virtual table type.
 …
 };
 \end{cfa}
 Both traits ensure a pair of types are an exception type and its virtual table
+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}.
 …
 \section{Exception Handling}
 \label{s:ExceptionHandling}
 \CFA provides two kinds of exception handling: termination and resumption.
+As stated, \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.
+This section covers the general patterns shared by the two operations and
+then go on to cover the details of each individual operation.
 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.
+Both start with the user performing a raise on an exception.
+Then the exception propagates 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 after the raise.
+After that control returns to a point specific to the kind of exception.
+If the search fails a default handler is run, and if it returns, control
+continues after the raise. Note, the default handler may further change control flow rather than return.
 This general description covers what the two kinds have in common.
 Differences include how propogation is preformed, where exception continues
+Differences include how propagation is performed, where exception continues
 after an exception is caught and handled and which default handler is run.
 \subsection{Termination}
 \label{s:Termination}
 Termination handling is the familiar kind and used in most programming
 languages with exception handling.
 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
+It is a dynamic, non-local goto. If the raised exception is matched and
+handled, the stack is unwound and control (usually) continues in the function
 on the call stack that defined the handler.
 Termination is commonly used when an error has occurred and recovery is
 …
 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
+Through \CFA's trait system, the trait functions are implicitly 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 to ensure
 the exception is not destroyed if the stack is unwound.
+change the throw's behaviour (see below).
+The throw copies the provided exception into managed memory to ensure
+the exception is not destroyed when 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
+up whether 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,
+Then propagation starts the search. \CFA uses a ``first match" rule so
+matching is performed with the copied exception as the search continues.
+It starts from the throwing function and proceeds towards the base of the stack,
 from callee to caller.
 At each stack frame, a check is made for resumption handlers defined by the
 …
+}
 \end{cfa}
 When viewed on its own, a try statement will simply execute the statements
 in \snake{GUARDED_BLOCK} and when those are finished the try statement finishes.
+When viewed on its own, a try statement simply executes the statements
+in \snake{GUARDED_BLOCK} and when those are finished, the try statement 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 termination exception is thrown and not handled further up the
 stack they will be matched against the exception.
+invoked functions, all the handlers in these statements are included on the search
+path. Hence, if a termination exception is raised, the search includes the added handlers associated with the guarded block and those further up the
+stack from the guarded block.
 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
+they appear, top to bottom. If the representation of the raised 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
+(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 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.
+If no termination handler is found during the search, the default handler
+(\defaultTerminationHandler) visible at the raise statement is called.
+Through \CFA's trait system, the best match at the raise sight is used.
+This function is run and is passed the copied exception. If the default
+handler returns, control continues after the throw statement.
 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.
+termination exception types. Since it is so general, a more specific handler can be
+defined and is used for those types, effectively overriding the handler
+for a particular exception type.
 The global default termination handler performs a cancellation
 (see \vref{s:Cancellation}) on the current stack with the copied exception.
 …
 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.
+matched a closure is taken from up the stack and executed,
+after which the raising function continues executing.
+These are most often used when a potentially repairable error occurs, some handler is found on the stack to fix it, and
+the raising function can continue with the correction.
+Another common usage is dynamic event analysis, \eg logging, without disrupting control flow.
+Note, if an event is raised and there is no interest, control continues normally.
+\PAB{We also have \lstinline{report} instead of \lstinline{throwResume}, \lstinline{recover} instead of \lstinline{catch}, and \lstinline{fixup} instead of \lstinline{catchResume}.
+You may or may not want to mention it. You can still stick with \lstinline{catch} and \lstinline{throw/catchResume} in the thesis.}
 A resumption raise is started with the @throwResume@ statement:
 …
 @is_resumption_exception@ at the call site.
 The assertions from this trait are available to
 the exception system while handling the exception.
 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.
+the exception system, while handling the exception.
+Resumption does not need to copy the raised exception, as the stack is not unwound.
+The exception and
+any values on the stack remain in scope, while the resumption is handled.
 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.
+resuming function and proceeds towards 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.
 …
 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.
+Each type of handler only interacts with exceptions from the matching
+kind of raise.
+When a try statement is executed, it simply executes the statements in the
+@GUARDED_BLOCK@ and then returns.
 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.
+invoked functions, all the handlers in these statements are included on the search
+path. Hence, if a resumption exception is raised the search includes the added handlers associated with the guarded block and those further up the
+stack from the guarded block.
 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
+they appear, top to bottom. If the representation of the raised 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
 …
 the raise statement that raised the handled exception.
+Like termination, if no resumption handler is found, the default handler
+visible at the throw statement is called. It will use the best match at the
+call sight according to \CFA's overloading rules. The default handler is
+Like termination, if no resumption handler is found during the search, the default handler
+(\defaultResumptionHandler) visible at the raise statement is called.
+It uses the best match at the
+raise 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 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 raise is matched at the
+original raise statement (the resumption @throw@\-@Resume@) and it can be
+There is a global \defaultResumptionHandler{} that is polymorphic over all
+resumption exception types and preforms a termination throw on the exception.
+The \defaultTerminationHandler{} can be
 customized by introducing a new or better match as well.
 \subsubsection{Resumption Marking}
 \label{s:ResumptionMarking}
 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
 and run it's try block (the guarded statements) and every try statement
 searched before it are still on the stack. This can lead to the recursive
+and run, its try block (the guarded statements) and every try statement
+searched before it are still on the stack. Their existence can lead to the recursive
 resumption problem.
 …
+}
 \end{cfa}
 When this code is executed the guarded @throwResume@ will throw, start a
 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 search the same try block and put call another instance of the
 same handler leading to an infinite loop.
 This situation is trivial and easy to avoid, but much more complex cycles
+When this code is executed, the guarded @throwResume@ starts a
+search and matchs the handler in the @catchResume@ clause. This
+call is placed on the top of stack above the try-block. The second throw
+searchs the same try block and puts call another instance of the
+same handler on the stack leading to an infinite recursion.
+While this situation is trivial and easy to avoid, much more complex cycles
 can form with multiple handlers and different exception types.
 To prevent all of these cases we mark try statements on the stack.
+To prevent all of these cases, the exception search marks the try statements it visits.
 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
+exception. The statement is 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.
+While a try statement is marked, its handlers are never matched, effectify
+skipping over them to the next try statement.
 \begin{center}
 …
 These rules mirror what happens with termination.
 When a termination throw happens in a handler the search will not look at
+When a termination throw happens in a handler, the search does not look at
 any handlers from the original throw to the original catch because that
 part of the stack has been unwound.
+part of the stack is 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 more rules to remember.
+but with marking, the search does match exceptions for try statements at equivalent sections
+that would have been unwound by termination.
+The symmetry between resumption termination is why this pattern is picked.
+Other patterns, such as marking just the handlers that caught the exception, also work but
+lack the symmetry, meaning there are more rules to remember.
 \section{Conditional Catch}
 Both termination and resumption handler clauses can be given an additional
 condition to further control which exceptions they handle:
 …
 did not match.
 The condition matching allows finer matching by allowing the match to check
+The condition matching allows finer matching to check
 more kinds of information than just the exception type.
 \begin{cfa}
 …
 // 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
+In this example, the file that experianced the IO error is used to decide
 which handler should be run, if any at all.
 …
 \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.
+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:
+If @throw@ is used to start a termination reraise then these two statements
+have the same behaviour:
 \begin{cfa}
 try {
 …
+}
 \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 that 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
+However, if there are further handlers after this handler only the first is
+check. For multiple handlers on a single try block that could handle the
+same exception, the equivalent translations to conditional catch becomes more complex, resulting is multiple nested try blocks for all possible reraises.
+So while catch-with-reraise is logically equivilant to conditional catch, there is a lexical explosion for the former.
+\PAB{I think the following discussion makes an incorrect assumption.
+A conditional catch CAN happen with the stack unwound.
+Roy talked about this issue in Section 2.3.3 here: \newline
+\url{http://plg.uwaterloo.ca/theses/KrischerThesis.pdf}}
+Specifically for 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
+another issue, if the exception is not 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
+There are two problems with this: the site of the original raise does not
+exist anymore and the default handler might not exist anymore. The site is
+always 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.
 …
 \section{Finally Clauses}
 \label{s:FinallyClauses}
 Finally clauses are used to preform unconditional clean-up when leaving a
 scope and are placed at the end of a try statement after any handler clauses:
 …
 The @FINALLY_BLOCK@ is executed when the try statement is removed from the
 stack, including when the @GUARDED_BLOCK@ finishes, any termination handler
 finishes or during an unwind.
+finishes, or during an unwind.
 The only time the block is not executed is if the program is exited before
 the stack is unwound.
 …
 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 one-off uses and
 can easily include local information.
+without it as destructors with RAII serve a similar role. Although destructors and
+finally clauses have overlapping usage cases, they have their own
+specializations, like top-level functions and lambda functions with closures.
+Destructors take more work if a number of unrelated, local variables without destructors or dynamically allocated variables must be passed for de-intialization.
+Maintaining this destructor during local-block modification is a source of errors.
+A finally clause places local de-intialization inline with direct access to all local variables.
 \section{Cancellation}
 …
 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.)
+(This restriction 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.
+unwound.
+The result of a cancellation depends on the kind of stack that is being unwound.
 \paragraph{Main Stack}
 …
 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
+There are two reasons for this semantics. The first is that it obviously had to do the abort
 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.
+\PAB{I do not understand this sentence. $\Rightarrow$ Also, even in concurrent programs, there is no stack that an innate connection
+to, so it would have be explicitly managed.}
 \paragraph{Thread Stack}
 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
+After a thread stack is unwound, the 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.
+cancellation, is reported from the join to the joining thread.
 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
+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.
+\PAB{Communication can occur during the lifetime of a thread using shared variable and \lstinline{waitfor} statements.
+Are you sure you mean communication here? Maybe you mean synchronization (rendezvous) point. $\Rightarrow$ Communication is done at join because a thread only has two 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.
+before the join, so join is use.
 % TODO: Find somewhere to discuss unwind collisions.
 …
 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
+After a coroutine stack is unwound, control returns to the @resume@ function
+that most recently resumed it. The resume reports a
+@CoroutineCancelled@ exception, which contains 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.
+The @resume@ function also takes the \defaultResumptionHandler{} from the
+caller's context and passes it to the internal cancellation.
 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
+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.

doc/theses/andrew_beach_MMath/future.tex

r82f4063	rbae0d35
1	1	\chapter{Future Work}
	2	\label{c:future}
2	3
3	4	\section{Language Improvements}

doc/theses/andrew_beach_MMath/implement.tex

r82f4063	rbae0d35
1	1	\chapter{Implementation}
2		% Goes over how all the features are implemented.
	2	\label{c:implement}
3	3
4	4	The implementation work for this thesis covers two components: the virtual

doc/theses/andrew_beach_MMath/intro.tex

-              r82f4063
+              rbae0d35
 \chapter{Introduction}
+\PAB{Stay in the present tense. \newline
+\url{https://plg.uwaterloo.ca/~pabuhr/technicalWriting.shtml}}
+\newline
+\PAB{Note, \lstinline{lstlisting} normally bolds keywords. None of the keywords in your thesis are bolded.}
 % Talk about Cforall and exceptions generally.
+%This thesis goes over the design and implementation of the exception handling
+%mechanism (EHM) of
+%\CFA (pernounced sea-for-all and may be written Cforall or CFA).
+Exception handling provides alternative dynamic inter-function control flow.
+There are two forms of exception handling covered in this thesis:
+termination, which acts as a multi-level return,
+and resumption, which is a dynamic function call.
+Note, termination exception handling is so common it is often assumed to be the only form.
+Lesser know derivations of inter-function control flow are continuation passing in Lisp~\cite{CommonLisp}.
+Termination exception handling allows control to return to any previous
+function on the stack directly, skipping any functions between it and the
+current function.
+\begin{center}
+\input{callreturn}
+\end{center}
+Resumption exception handling calls a function, but asks the functions on the
+stack what function that is.
+\todo{Add a diagram showing control flow for resumption.}
+Although a powerful feature, exception handling tends to be complex to set up
+and expensive to use
+so they are often limited to unusual or ``exceptional" cases.
+The classic example of this is error handling, exceptions can be used to
+remove error handling logic from the main execution path and while paying
+most of the cost only when the error actually occurs.
+% Overview of exceptions in Cforall.
+\PAB{You need section titles here. Don't take them out.}
+\section{Thesis Overview}
 This thesis goes over the design and implementation of the exception handling
 mechanism (EHM) of
+\CFA (pernounced sea-for-all, can also be written Cforall or CFA).
+Exception handling provides dynamic inter-function control flow. Although
+a powerful feature they tend to be expensive to use so they are often limited
+to unusual or ``exceptional" cases.
+The classic example of this is error handling, exceptions can be used to
+remove error handling logic from the main execution path and paying most of
+the cost only when the error actually occurs.
+% Overview of exceptions in Cforall.
+\CFA (pernounced sea-for-all and may be written Cforall or CFA).
+%This thesis describes the design and implementation of the \CFA EHM.
 The \CFA EHM implements all of the common exception features (or an
 equivalent) found in most other EHMs and adds some features of its own.
 …
 % A note that yes, that was a very fast overview.
 All the design and implementation of all of \CFA's EHM's features are
 described in detail later in this thesis, whether they are a common feature
+The design and implementation of all of \CFA's EHM's features are
+described in detail throughout this thesis, whether they are a common feature
 or one unique to \CFA.
 % The current state of the project and what it contributes.
 All of these features have been added to the \CFA implemenation, along with
 a suite of test cases.
+All of these features have been implemented in \CFA, along with
+a suite of test cases as part of this project.
 The implementation techniques are generally applicable in other programming
+languages and much of the design is as well, although occationally
+replacements for some of \CFA's more unusual feature would have to be found.
+languages and much of the design is as well.
+Some parts of the EHM use other features unique to \CFA and these would be
+harder to replicate in other programming languages.
+\section{Background}
+% Talk about other programming languages.
+Some existing programming languages that include EHMs/exception handling
+include C++, Java and Python. All three examples focus on termination
+exceptions which unwind the stack as part of the
+Exceptions also can replace return codes and return unions.
+In functional languages will also sometimes fold exceptions into monads.
+\PAB{You must demonstrate knowledge of background material here.
+It should be at least a full page.}
+\section{Contributions}
+The contributions of this work are:
+\begin{enumerate}
+\item Designing \CFA's exception handling mechanism, adapting designs from
+other programming languages and the creation of new features.
+\item Implementing stack unwinding and the EHM in \CFA, including updating
+the compiler and the run-time environment.
+\item Designed and implemented a prototype virtual system.
+% I think the virtual system and per-call site default handlers are the only
+% "new" features, everything else is a matter of implementation.
+\end{enumerate}
+\todo{I can't figure out a good lead-in to the overview.}
+Covering the existing \CFA features in \autoref{c:existing}.
+Then the new features are introduce in \autoref{c:features}, explaining their
+usage and design.
+That is followed by the implementation of those features in
+\autoref{c:implement}.
+% Future Work \autoref{c:future}

doc/theses/thierry_delisle_PhD/thesis/thesis.tex

r82f4063	rbae0d35
193	193
194	194	% cfa macros used in the document
195		\~~usepackage~~{common}
	195	\input{common}
196	196	\CFAStyle % CFA code-style for all languages
197	197	\lstset{language=CFA,basicstyle=\linespread{0.9}\tt} % CFA default language

doc/user/user.tex

-              r82f4063
+              rbae0d35
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Sat May  8 08:51:33 2021
 %% Update Count     : 5062
+%% Last Modified On : Mon May 31 09:03:34 2021
+%% Update Count     : 5071
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \usepackage{epic,eepic}
 \usepackage{upquote}                                                                    % switch curled `'" to straight
-\usepackage{calc}
-\usepackage{varioref}                                                                   % extended references
 \usepackage[labelformat=simple,aboveskip=0pt,farskip=0pt]{subfig}
 \renewcommand{\thesubfigure}{\alph{subfigure})}
 …
 \usepackage{mathptmx}                                   % better math font with "times"
 \usepackage[usenames]{color}
-\usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
-\usepackage{breakurl}
-\renewcommand\footnoterule{\kern -3pt\rule{0.3\linewidth}{0.15pt}\kern 2pt}
-\usepackage[pagewise]{lineno}
-\renewcommand{\linenumberfont}{\scriptsize\sffamily}
-\usepackage[firstpage]{draftwatermark}
-\SetWatermarkLightness{0.9}
-% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
-% removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
-% AFTER HYPERREF.
-\renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
-\setlength{\topmargin}{-0.45in}                                                 % move running title into header
-\setlength{\headsep}{0.25in}
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \newcommand{\CFALatin}{}
 % inline code ©...© (copyright symbol) emacs: C-q M-)
 …
 \usepackage{common}                                                                             % common CFA document macros
 %\input{common}                                                                                 % common CFA document macros
+\usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
+\usepackage{breakurl}
+\renewcommand\footnoterule{\kern -3pt\rule{0.3\linewidth}{0.15pt}\kern 2pt}
+\usepackage[pagewise]{lineno}
+\renewcommand{\linenumberfont}{\scriptsize\sffamily}
+\usepackage[firstpage]{draftwatermark}
+\SetWatermarkLightness{0.9}
+% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
+% removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
+% AFTER HYPERREF.
+\renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
+\setlength{\topmargin}{-0.45in}                                                 % move running title into header
+\setlength{\headsep}{0.25in}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \setlength{\gcolumnposn}{3in}
 \CFAStyle                                                                                               % use default CFA format-style
 \lstset{language=CFA}                                                                   % CFA default lnaguage
+%\lstset{language=CFA}                                                                  % CFA default lnaguage
 \lstnewenvironment{C++}[1][]                            % use C++ style
 {\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®},#1}}
 …
 In contrast, \CFA has 30 years of hindsight and a clean starting point.
 Like \Index*[C++]{\CC{}}, there may be both an old and new ways to achieve the same effect.
+Like \Index*[C++]{\CC{}}, there may be both old and new ways to achieve the same effect.
 For example, the following programs compare the C, \CFA, and \CC I/O mechanisms, where the programs output the same result.
 \begin{center}
 …
 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( T )® T identity( T val ) { return val; }
 int forty_two = identity( 42 ); $\C{// T is bound to int, forty\_two == 42}$
 \end{cfa}
 …
 which can be augmented simply with a polymorphic, type-safe, \CFA-overloaded wrappers:
 \begin{cfa}
 forall( otype T | { int ?<?( T, T ); } ) T * bsearch( T key, const T * arr, size_t size ) {
+forall( T | { int ?<?( T, T ); } ) T * bsearch( T key, const T * arr, size_t size ) {
         int comp( const void * t1, const void * t2 ) { /* as above with double changed to T */ }
         return (T *)bsearch( &key, arr, size, sizeof(T), comp ); }
 forall( otype T | { int ?<?( T, T ); } ) unsigned int bsearch( T key, const T * arr, size_t size ) {
+forall( T | { int ?<?( T, T ); } ) unsigned int bsearch( T key, const T * arr, size_t size ) {
         T * result = bsearch( key, arr, size ); $\C{// call first version}$
         return result ? result - arr : size; } $\C{// pointer subtraction includes sizeof(T)}$
 …
 Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
 \begin{cfa}
 int ®``®otype = 3; $\C{// make keyword an identifier}$
+int ®``®coroutine = 3; $\C{// make keyword an identifier}$
 double ®``®forall = 3.5;
 \end{cfa}
 …
 The exponentiation operator is available for all the basic types, but for user-defined types, only the integral-computation version is available.
 \begin{cfa}
 forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
+forall( T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
 T ?®\®?( T ep, unsigned int y );
 forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
+forall( T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
 T ?®\®?( T ep, unsigned long int y );
 \end{cfa}
 …
   case 1:  case 2:  case 3:
         ...
         ®// implicit end of switch (break)
   ®case 5:
+        $\R{\LstCommentStyle{// implicit end of switch (break)}}$
+  case 5:
         ...
         ®fallthru®; $\C{// explicit fall through}$
 …
 For example, the C quick-sort is wrapped into the following polymorphic \CFA routine:
 \begin{cfa}
 forall( otype T | { int ?<?( T, T ); } )
+forall( T | { int ?<?( T, T ); } )
 void qsort( const T * arr, size_t dimension );
 \end{cfa}
 …
 The integration of polymorphism, type assertions, and monomorphic specialization of tuple-assertions are a primary contribution of this thesis to the design of tuples.
 \begin{cfa}
 forall(otype T, dtype U)
+forall(T, dtype U)
 void f(T x, U * y);
 …
 The argument matching algorithm binds ©T© to ©int© and ©U© to ©const char©, and calls the function as normal.
 Tuples can contain otype and dtype components.
+Tuples can contain polymorphic types.
 For example, a plus operator can be written to add two triples of a type together.
 \begin{cfa}
 forall(otype T | { T ?+?(T, T); })
+forall(T | { T ?+?(T, T); })
 [T, T, T] ?+?([T, T, T] x, [T, T, T] y) {
         return [x.0+y.0, x.1+y.1, x.2+y.2];
 …
 Furthermore, these calls can be made ambiguous by introducing seemingly different functions.
 \begin{cfa}
 forall(otype T | { T ?+?(T, T); })
+forall(T | { T ?+?(T, T); })
 [T, T, T] ?+?([T, T] x, [T, T, T, T]);
 forall(otype T | { T ?+?(T, T); })
+forall(T | { T ?+?(T, T); })
 [T, T, T] ?+?(T x, [T, T, T, T, T]);
 \end{cfa}
 …
 \begin{cfa}
 int f([int, double], double);
 forall(otype T, otype U | { T f(T, U, U); })
+forall(T, U | { T f(T, U, U); })
 void g(T, U);
 g(5, 10.21);
 …
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 forall( otype T | { int ?<?( T, T ); } ) $\C{// location}$
+forall( T | { int ?<?( T, T ); } ) $\C{// location}$
 T * bsearch( T key, const T * arr, size_t dim );$\indexc{bsearch}$
 forall( otype T | { int ?<?( T, T ); } ) $\C{// position}$
+forall( T | { int ?<?( T, T ); } ) $\C{// position}$
 unsigned int bsearch( T key, const T * arr, size_t dim );
 forall( otype T | { int ?<?( T, T ); } )
+forall( T | { int ?<?( T, T ); } )
 void qsort( const T * arr, size_t dim );$\indexc{qsort}$
 forall( otype E | { int ?<?( E, E ); } ) {
+forall( E | { int ?<?( E, E ); } ) {
         E * bsearch( E key, const E * vals, size_t dim );$\indexc{bsearch}$ $\C{// location}$
         size_t bsearch( E key, const E * vals, size_t dim );$\C{// position}$
 …
+}
 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) {
+forall( K, E | { int ?<?( K, K ); K getKey( const E & ); } ) {
         E * bsearch( K key, const E * vals, size_t dim );
         size_t bsearch( K key, const E * vals, size_t dim );
 …
+}
 forall( otype E | { int ?<?( E, E ); } ) {
+forall( E | { int ?<?( E, E ); } ) {
         void qsort( E * vals, size_t dim );$\indexc{qsort}$
+}
 …
 double abs( double _Complex );
 long double abs( long double _Complex );
 forall( otype T | { void ?{}( T *, zero_t ); int ?<?( T, T ); T -?( T ); } )
+forall( T | { void ?{}( T *, zero_t ); int ?<?( T, T ); T -?( T ); } )
 T abs( T );
 \end{cfa}
 …
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 forall( otype T | { int ?<?( T, T ); } ) T min( T t1, T t2 );$\indexc{min}$
 forall( otype T | { int ?>?( T, T ); } ) T max( T t1, T t2 );$\indexc{max}$
 forall( otype T | { T min( T, T ); T max( T, T ); } ) T clamp( T value, T min_val, T max_val );$\indexc{clamp}$
 forall( otype T ) void swap( T * t1, T * t2 );$\indexc{swap}$
+forall( T | { int ?<?( T, T ); } ) T min( T t1, T t2 );$\indexc{min}$
+forall( T | { int ?>?( T, T ); } ) T max( T t1, T t2 );$\indexc{max}$
+forall( T | { T min( T, T ); T max( T, T ); } ) T clamp( T value, T min_val, T max_val );$\indexc{clamp}$
+forall( T ) void swap( T * t1, T * t2 );$\indexc{swap}$
 \end{cfa}

driver/cc1.cc

-              r82f4063
+              rbae0d35
 // Created On       : Fri Aug 26 14:23:51 2005
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Nov 17 14:27:08 2020
 // Update Count     : 414
+// Last Modified On : Tue Jun  1 23:07:21 2021
+// Update Count     : 415
 //
 …
                                 if ( arg == "-D" || arg == "-U" || arg == "-I" || arg == "-MF" || arg == "-MT" || arg == "-MQ" ||
                                          arg == "-include" || arg == "-imacros" || arg == "-idirafter" || arg == "-iprefix" ||
+                                         arg == "-iwithprefix" || arg == "-iwithprefixbefore" || arg == "-isystem" || arg == "-isysroot" ) {
+                                         arg == "-iwithprefix" || arg == "-iwithprefixbefore" || arg == "-isystem" || arg == "-isysroot" ||
+                                         arg == "-dumpbase-ext" || arg == "-dumpbase"
+                                        ) {
                                         i += 1;
                                         args[nargs++] = argv[i];                        // pass argument along
 …
                                 // strip inappropriate flags with an argument
                         } else if ( arg == "-auxbase" || arg == "-auxbase-strip" || arg == "-dumpbase" ) {
+                        } else if ( arg == "-auxbase" || arg == "-auxbase-strip" || arg == "-dumpbase" || arg == "-dumpdir" ) {
                                 i += 1;
                                 #ifdef __DEBUG_H__

libcfa/src/Makefile.am

-              r82f4063
+              rbae0d35
 inst_thread_headers_src = \
+        concurrency/alarm.hfa \
         concurrency/coroutine.hfa \
         concurrency/exception.hfa \
 …
 thread_libsrc = ${inst_thread_headers_src} ${inst_thread_headers_src:.hfa=.cfa} \
         bits/signal.hfa \
-        concurrency/alarm.cfa \
-        concurrency/alarm.hfa \
         concurrency/clib/cfathread.cfa \
         concurrency/CtxSwitch-@ARCHITECTURE@.S \

libcfa/src/concurrency/coroutine.cfa

-              r82f4063
+              rbae0d35
                 struct $coroutine * cor = active_coroutine();
+                // get the active thread once
+                $thread * athrd = active_thread();
+                /* paranoid */ verify( athrd->corctx_flag );
+                athrd->corctx_flag = false;
                 if(cor->state == Primed) {
                         __cfactx_suspend();

libcfa/src/concurrency/coroutine.hfa

-              r82f4063
+              rbae0d35
         src->state = src->state == Halted ? Halted : Blocked;
+        // get the active thread once
+        $thread * athrd = active_thread();
+        // Mark the coroutine
+        /* paranoid */ verify( !athrd->corctx_flag );
+        athrd->corctx_flag = true;
         // set new coroutine that task is executing
         active_thread()->curr_cor = dst;
+        athrd->curr_cor = dst;
         // context switch to specified coroutine
         verify( dst->context.SP );
+        /* paranoid */ verify( dst->context.SP );
         __cfactx_switch( &src->context, &dst->context );
         // when __cfactx_switch returns we are back in the src coroutine
+        /* paranoid */ verify( athrd->corctx_flag );
+        athrd->corctx_flag = false;
         // set state of new coroutine to active

libcfa/src/concurrency/invoke.h

r82f4063	rbae0d35
168	168	enum __Preemption_Reason preempted:8;
169	169
	170	bool corctx_flag;
	171
170	172	//SKULLDUGGERY errno is not save in the thread data structure because returnToKernel appears to be the only function to require saving and restoring it
171	173

libcfa/src/concurrency/kernel.cfa

-              r82f4063
+              rbae0d35
                 /* paranoid */ verify( thrd_dst->context.SP );
                 /* paranoid */ verify( thrd_dst->state != Halted );
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
+                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
+                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
                 /* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd_dst->canary );
 …
                 /* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd_dst->canary );
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit), "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst );
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ), "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst );
+                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst );
+                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst );
                 /* paranoid */ verify( thrd_dst->context.SP );
                 /* paranoid */ verify( thrd_dst->curr_cluster == this->cltr );

libcfa/src/concurrency/kernel/startup.cfa

r82f4063	rbae0d35
397	397	// make sure the current state is still correct
398	398	/* paranoid */ verify(src->state == Ready);
	399	src->corctx_flag = true;
399	400
400	401	// context switch to specified coroutine

libcfa/src/concurrency/thread.cfa

r82f4063	rbae0d35
32	32	state = Start;
33	33	preempted = __NO_PREEMPTION;
	34	corctx_flag = false;
34	35	curr_cor = &self_cor;
35	36	self_mon.owner = &this;

src/AST/Pass.proto.hpp

r82f4063	rbae0d35
119	119	template<typename core_t, typename node_t>
120	120	struct is_valid_previsit {
121		using ret_t = decltype( ~~((core_t)nullptr)->previsit( (const node_t )nullptr~~ ) );
	121	using ret_t = decltype( std::declval<core_t>()->previsit( std::declval<const node_t >() ) );
122	122
123	123	static constexpr bool value = std::is_void< ret_t >::value \|\|

src/AST/Type.hpp

-              r82f4063
+              rbae0d35
         // compact representation used for map lookups.
         struct TypeEnvKey {
                 const TypeDecl * base;
                 int formal_usage;
                 int expr_id;
+        struct TypeEnvKey {
+                const TypeDecl * base = nullptr;
+                int formal_usage = 0;
+                int expr_id = 0;
                 TypeEnvKey() = default;
 …
         const Type * accept( Visitor & v ) const override { return v.visit( this ); }
         std::string typeString() const {
                 if (formal_usage > 0) return std::string("_") + std::to_string(formal_usage) + "_" + std::to_string(expr_id) + "_" + name;
+        std::string typeString() const {
+                if (formal_usage > 0) return std::string("_") + std::to_string(formal_usage) + "_" + std::to_string(expr_id) + "_" + name;
                 else return name;
+        }
 …
                         res = p * res + x.expr_id;
                         return res;
+                }
+                }
         };
+}

src/AST/TypeEnvironment.cpp

r82f4063	rbae0d35
115	115
116	116	void TypeEnvironment::add( const TypeSubstitution & sub ) {
117		for ( const auto p : sub ) {
	117	for ( const auto & p : sub ) {
118	118	add( EqvClass{ p.first, p.second } );
119	119	}

src/CodeTools/ResolvProtoDump.cc

-              r82f4063
+              rbae0d35
                         // print child scopes
                         ++indent;
                         for ( const PassVisitor<ProtoDump>& s : subs ) {
+                        for ( const ProtoDump & s : subs ) {
                                 std::cout << tab << '{' << std::endl;
                                 s.pass.print( indent );
+                                s.print( indent );
                                 std::cout << tab << '}' << std::endl;
+                        }

src/main.cc

-              r82f4063
+              rbae0d35
 #define SIGPARMS int sig __attribute__(( unused )), siginfo_t * sfp __attribute__(( unused )), ucontext_t * cxt __attribute__(( unused ))
+static void Signal( int sig, void (* handler)(SIGPARMS), int flags ) {
+        struct sigaction act;
+        act.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler;
+static void _Signal(struct sigaction & act, int sig, int flags ) {
         act.sa_flags = flags;
 …
             _exit( EXIT_FAILURE );
         } // if
+}
+static void Signal( int sig, void (* handler)(SIGPARMS), int flags ) {
+        struct sigaction act;
+        act.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler;
+        _Signal(act, sig, flags);
+} // Signal
+static void Signal( int sig, void (* handler)(int), int flags ) {
+        struct sigaction act;
+        act.sa_handler = handler;
+        _Signal(act, sig, flags);
 } // Signal
 …
 static void sigAbortHandler( SIGPARMS ) {
         backtrace( 6 );                                                                         // skip first 6 stack frames
         Signal( SIGABRT, (void (*)(SIGPARMS))SIG_DFL, SA_SIGINFO );     // reset default signal handler
+        Signal( SIGABRT, SIG_DFL, SA_SIGINFO ); // reset default signal handler
         raise( SIGABRT );                                                                       // reraise SIGABRT
 } // sigAbortHandler

tests/.expect/array.txt

r82f4063	rbae0d35
1		array.cfa: In function '_X4mainFi___1':
2		array.cfa:55:9: note: #pragma message: Compiled
	1	array.cfa:52:25: warning: Compiled

tests/.expect/cast.txt

r82f4063	rbae0d35
1		cast.cfa: In function '_X4mainFi_iPPKc__1':
2		cast.cfa:18:9: note: #pragma message: Compiled
	1	cast.cfa:16:25: warning: Compiled

tests/.expect/expression.txt

r82f4063	rbae0d35
1		expression.cfa: In function '_X4mainFi___1':
2		expression.cfa:89:9: note: #pragma message: Compiled
	1	expression.cfa:86:25: warning: Compiled

tests/.expect/forall.txt

r82f4063	rbae0d35
1		forall.cfa: In function '_X4mainFi___1':
2		forall.cfa:218:9: note: #pragma message: Compiled
	1	forall.cfa:216:25: warning: Compiled

tests/.expect/identFuncDeclarator.txt

r82f4063	rbae0d35
1		identFuncDeclarator.cfa: In function '_X4mainFi___1':
2		identFuncDeclarator.cfa:116:9: note: #pragma message: Compiled
	1	identFuncDeclarator.cfa:114:25: warning: Compiled

tests/.expect/init1-ERROR.nast.txt

r82f4063	rbae0d35
	1	init1.cfa:134:25: warning: Compiled
1	2	init1.cfa:56:1 error: Invalid application of existing declaration(s) in expression Untyped Init Expression
2	3	Name: rx InitAlternative: reference to signed int

tests/.expect/init1.txt

r82f4063	rbae0d35
1		init1.cfa: In function '_X4mainFi___1':
2		init1.cfa:136:9: note: #pragma message: Compiled
	1	init1.cfa:134:25: warning: Compiled

tests/.expect/labelledExit.txt

r82f4063	rbae0d35
1		labelledExit.cfa: In function '_X4mainFi_iPPKc__1':
2		labelledExit.cfa:183:9: note: #pragma message: Compiled
	1	labelledExit.cfa:181:25: warning: Compiled

tests/.expect/limits.txt

r82f4063	rbae0d35
1		limits.cfa: In function '_X4mainFi_iPPKc__1':
2		limits.cfa:154:9: note: #pragma message: Compiled
	1	limits.cfa:152:25: warning: Compiled

tests/.expect/nested-types-ERR1.txt

r82f4063	rbae0d35
	1	nested-types.cfa:100:25: warning: Compiled
1	2	nested-types.cfa:83:1 error: Use of undefined type T

tests/.expect/nested-types-ERR2.txt

r82f4063	rbae0d35
	1	nested-types.cfa:100:25: warning: Compiled
1	2	nested-types.cfa:86:1 error: Use of undefined global type Z
2	3	nested-types.cfa:87:1 error: Qualified type requires an aggregate on the left, but has: signed int

tests/.expect/nested-types.txt

r82f4063	rbae0d35
1		nested-types.cfa: In function '_X4mainFi___1':
2		nested-types.cfa:102:9: note: #pragma message: Compiled
	1	nested-types.cfa:100:25: warning: Compiled

tests/.expect/numericConstants.txt

r82f4063	rbae0d35
1		numericConstants.cfa: In function '_X4mainFi___1':
2		numericConstants.cfa:68:9: note: #pragma message: Compiled
	1	numericConstants.cfa:66:25: warning: Compiled

tests/.expect/quasiKeyword.txt

r82f4063	rbae0d35
1		quasiKeyword.cfa: In function '_X4mainFi_iPPKc__1':
2		quasiKeyword.cfa:56:9: note: #pragma message: Compiled
	1	quasiKeyword.cfa:54:25: warning: Compiled

tests/.expect/switch.txt

r82f4063	rbae0d35
1		switch.cfa: In function '_X4mainFi___1':
2		switch.cfa:105:9: note: #pragma message: Compiled
	1	switch.cfa:103:25: warning: Compiled

tests/.expect/typedefRedef-ERR1.txt

r82f4063	rbae0d35
	1	typedefRedef.cfa:69:25: warning: Compiled
1	2	typedefRedef.cfa:4:1 error: Cannot redefine typedef: Foo
2	3	typedefRedef.cfa:59:1 error: Cannot redefine typedef: ARR

tests/.expect/typedefRedef.txt

r82f4063	rbae0d35
1		typedefRedef.cfa: In function '_X4mainFi___1':
2		typedefRedef.cfa:71:9: note: #pragma message: Compiled
	1	typedefRedef.cfa:69:25: warning: Compiled

tests/.expect/variableDeclarator.txt

r82f4063	rbae0d35
1		variableDeclarator.cfa: In function '_X4mainFi_iPPKc__1':
2		variableDeclarator.cfa:182:9: note: #pragma message: Compiled
	1	variableDeclarator.cfa:180:25: warning: Compiled

tests/Makefile.am

-              r82f4063
+              rbae0d35
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Tue Mar  2 21:39:01 2021
 ## Update Count     : 90
+## Last Modified On : Sat Jun  5 14:49:25 2021
+## Update Count     : 92
 ###############################################################################
 …
 SYNTAX_ONLY_CODE = expression typedefRedef variableDeclarator switch numericConstants identFuncDeclarator forall \
         init1 limits nested-types stdincludes cast labelledExit array quasiKeyword include/includes builtins/sync warnings/self-assignment
+        init1 limits nested-types cast labelledExit array quasiKeyword include/stdincludes include/includes builtins/sync warnings/self-assignment
 $(SYNTAX_ONLY_CODE): % : %.cfa $(CFACCBIN)
         $(CFACOMPILE_SYNTAX)

tests/array.cfa

-              r82f4063
+              rbae0d35
 // Created On       : Tue Feb 19 21:18:06 2019
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Sep 27 09:05:40 2020
 // Update Count     : 4
+// Last Modified On : Sat Jun  5 10:05:51 2021
+// Update Count     : 5
 //
 …
 int main() {
+        #if !defined(NO_COMPILED_PRAGMA)
+                #pragma message( "Compiled" )   // force non-empty .expect file
+        #endif
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+}

tests/builtins/.expect/sync.txt

r82f4063	rbae0d35
1		builtins/sync.cfa: In function '_X4mainFi___1':
2		builtins/sync.cfa:358:9: note: #pragma message: Compiled
	1	builtins/sync.cfa:356:25: warning: Compiled

tests/builtins/sync.cfa

r82f4063	rbae0d35
354	354
355	355	int main() {
356		#pragma message( "Compiled" ) // force non-empty .expect file
	356	#pragma GCC warning "Compiled" // force non-empty .expect file, NO TABS!!!
357	357	}

tests/cast.cfa

r82f4063	rbae0d35
14	14	//Dummy main
15	15	int main( int argc, char const * argv[] ) {
16		#pragma message( "Compiled" ) // force non-empty .expect file
	16	#pragma GCC warning "Compiled" // force non-empty .expect file, NO TABS!!!
17	17	}

tests/concurrent/.expect/sleep.txt

-              r82f4063
+              rbae0d35
 start
-fast loop 0.047
-fast loop 0.094
-fast loop 0.141
-fast loop 0.188
-fast loop 0.235
-slow loop 0.277
-fast loop 0.282
-fast loop 0.329
-fast loop 0.376
-fast loop 0.423
-fast loop 0.47
-fast loop 0.517
-slow loop 0.554
-fast loop 0.564
-fast loop 0.611
-fast loop 0.658
-fast loop 0.705
-fast loop 0.752
-fast loop 0.799
-slow loop 0.831
-fast loop 0.846
-fast loop 0.893
-fast loop 0.94
-slow loop 1.108
 done

tests/concurrent/sleep.cfa

r82f4063	rbae0d35
7	7	}
8	8
	9	volatile int counter = 0;
	10
9	11	thread fast_sleeper {};
10	12	void main(fast_sleeper &) {
…	…
12	14	for(i; 20) {
13	15	sleep(wait);
14		~~sout \| acquire \| "fast loop" \| ((1 + i) * wait~~);
	16	__atomic_fetch_add( &counter, 1, __ATOMIC_RELAXED );
15	17	}
16	18	}
…	…
20	22	Duration wait = 277`ms;
21	23	for(i; 4) {
22
23	24	sleep(wait);
24		sout \| acquire \| "slow loop" \| ((1 + i) * wait);
	25	int val = __atomic_add_fetch( &counter, -5, __ATOMIC_RELAXED );
	26	if(val < -9) abort \| "Value reached negative value:" \| val;
25	27	}
26	28	}

tests/expression.cfa

-              r82f4063
+              rbae0d35
         (S)@{2}`mary;
+        #if !defined(NO_COMPILED_PRAGMA)
+                #pragma message( "Compiled" )   // force non-empty .expect file
+        #endif
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
 } // main

tests/forall.cfa

-              r82f4063
+              rbae0d35
 // Created On       : Wed May  9 08:48:15 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Sep 27 08:43:20 2020
 // Update Count     : 35
+// Last Modified On : Sat Jun  5 10:06:08 2021
+// Update Count     : 36
 //
 …
 int main( void ) {
+        #pragma message( "Compiled" )                   // force non-empty .expect file
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+}

tests/identFuncDeclarator.cfa

-              r82f4063
+              rbae0d35
 // Created On       : Wed Aug 17 08:36:34 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Sep 27 08:20:46 2020
 // Update Count     : 5
+// Last Modified On : Sat Jun  5 10:06:25 2021
+// Update Count     : 6
 //
 …
         int (* const(* const f81)(int))();
+        #pragma message( "Compiled" )                   // force non-empty .expect file
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+}

tests/include/.expect/includes.nast.txt

r82f4063	rbae0d35
1		include/includes.cfa: In function '_X4mainFi_iPPKc__1':
2		include/includes.cfa:156:9: note: #pragma message: Compiled
	1	include/includes.cfa:154:25: warning: Compiled

tests/include/includes.cfa

-              r82f4063
+              rbae0d35
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 25 09:08:26 2021
 // Update Count     : 750
+// Last Modified On : Sat Jun  5 10:06:46 2021
+// Update Count     : 751
 //
 …
 int main( int argc, char const *argv[] ) {
+        #pragma message( "Compiled" )                                           // force non-empty .expect file
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+}

tests/include/stdincludes.cfa

-              r82f4063
+              rbae0d35
 // Created On       : Tue Aug 29 08:26:14 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Sep 27 08:51:38 2020
 // Update Count     : 8
+// Last Modified On : Sat Jun  5 10:08:11 2021
+// Update Count     : 9
 //
 …
 int main() {
+        #pragma message( "Compiled" )                   // force non-empty .expect file
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+}

tests/init1.cfa

-              r82f4063
+              rbae0d35
 // Created On       : Thu Jul 16 22:00:00 2020
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Oct 11 10:26:50 2020
 // Update Count     : 8
+// Last Modified On : Sat Jun  5 10:06:57 2021
+// Update Count     : 9
 //
 …
 int main() {
     #pragma message( "Compiled" )                       // force non-empty .expect file
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+}

tests/labelledExit.cfa

-              r82f4063
+              rbae0d35
 // Created On       : Wed Aug 10 07:29:39 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Sep 27 09:01:34 2020
 // Update Count     : 12
+// Last Modified On : Sat Jun  5 10:07:34 2021
+// Update Count     : 13
 //
 …
 int main( int argc, char const *argv[] ) {
+        #pragma message( "Compiled" )                                           // force non-empty .expect file
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+}

tests/limits.cfa

-              r82f4063
+              rbae0d35
 // Created On       : Tue May 10 20:44:20 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Sep 27 08:45:43 2020
 // Update Count     : 10
+// Last Modified On : Sat Jun  5 10:07:32 2021
+// Update Count     : 11
 //
 …
 int main(int argc, char const *argv[]) {
+        #pragma message( "Compiled" )                                           // force non-empty .expect file
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+}

tests/nested-types.cfa

-              r82f4063
+              rbae0d35
 // Created On       : Mon Jul 9 10:20:03 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Sep 27 08:48:59 2020
 // Update Count     : 6
+// Last Modified On : Sat Jun  5 10:07:42 2021
+// Update Count     : 7
 //
 …
         // A.N(int) x;  // xxx - should not be an error, but currently is.
+        #pragma message( "Compiled" )                   // force non-empty .expect file
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+}

tests/numericConstants.cfa

-              r82f4063
+              rbae0d35
 // Created On       : Wed May 24 22:10:36 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Sep 27 07:55:22 2020
 // Update Count     : 7
+// Last Modified On : Sat Jun  5 10:07:52 2021
+// Update Count     : 8
 //
 …
 x_1.ffff_ffff_p_128_l;
+        #pragma message( "Compiled" )   // force non-empty .expect file
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
 } // main

tests/pybin/tools.py

-              r82f4063
+              rbae0d35
         # make a directory for this test
         # mkdir makes the parent directory only so add a dummy
         mkdir(os.path.join(dst, name ))
+        mkdir( os.path.join(dst, "core") )
         # moves the files
         mv( core, os.path.join(dst, "core" ) )
         mv( exe , os.path.join(dst, name   ) )
+        mv( exe , os.path.join(dst, "exe"  ) )
         # return explanatory test

tests/quasiKeyword.cfa

-              r82f4063
+              rbae0d35
 // Created On       : Wed Feb 17 10:33:49 2021
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 21 15:52:04 2021
 // Update Count     : 7
+// Last Modified On : Sat Jun  5 10:07:59 2021
+// Update Count     : 8
 //
 …
         else catch = 3;
+        #pragma message( "Compiled" )                                           // force non-empty .expect file
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+}

tests/switch.cfa

-              r82f4063
+              rbae0d35
 // Created On       : Tue Jul 12 06:50:22 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Sep 27 08:35:02 2020
 // Update Count     : 43
+// Last Modified On : Sat Jun  5 10:08:20 2021
+// Update Count     : 44
 //
 …
         } // choose
+        #pragma message( "Compiled" )                                           // force non-empty .expect file
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
 } // main

tests/typedefRedef.cfa

r82f4063	rbae0d35
67	67	typedef int *** pt;
68	68
69		#pragma message( "Compiled" ) // force non-empty .expect file
	69	#pragma GCC warning "Compiled" // force non-empty .expect file, NO TABS!!!
70	70	}

tests/unified_locking/fast.cfa

-              r82f4063
+              rbae0d35
         fast_lock l;
         $thread * id;
         size_t sum;
+        uint32_t sum;
 };
 …
+}
 unsigned cs() {
+uint32_t cs() {
         $thread * me = active_thread();
         unsigned value = (unsigned)me;
+        uint32_t value = (uint32_t)me;
         lock(mo.l);
+        {
                 size_t tsum = mo.sum;
+                uint32_t tsum = mo.sum;
                 mo.id = me;
                 yield(random(5));
 …
 thread LockCheck {
         size_t sum;
+        uint32_t sum;
 };
 …
 int main() {
         size_t sum = -32;
+        uint32_t sum = -32;
         mo.sum = -32;
         processor p[2];

tests/unified_locking/timeout_lock.cfa

-              r82f4063
+              rbae0d35
 #include <stdio.h>
 #include "locks.hfa"
 #include "alarm.hfa"
+#include <locks.hfa>
+#include <alarm.hfa>
 #include <stdlib.hfa>
 #include <thread.hfa>
 #include "kernel.cfa"
+#include <kernel.hfa>
 multiple_acquisition_lock m, n;
 …
         for ( unsigned int i = 0; i < NoOfTimes + 3; i += 1 ) {
             if ( wait( c_m, m, 1000000`ns ) ) {
+            if ( wait( c_m, m, 1000000`ns ) ) {
                         // printf("Thread: %p signalled\n", active_thread()); // removed since can't expect non deterministic output
             } else {
 …
         processor p[2];
         printf("Start Test 1: surface testing condition variable timeout routines\n");
         wait( c_m, 1`ns );                                                                                                              // bool wait( condition_variable(L) & this, Duration duration );
+        wait( c_m, 1`ns );                                                                                                              // bool wait( condition_variable(L) & this, Duration duration );
         wait( c_m, 10, 1`ns );                                                                                                  // bool wait( condition_variable(L) & this, uintptr_t info, Duration duration );
         lock(m); wait( c_m, m, 1`ns ); unlock(m);                                                               // bool wait( condition_variable(L) & this, L & l, Duration duration );

tests/variableDeclarator.cfa

-              r82f4063
+              rbae0d35
 // Created On       : Wed Aug 17 08:41:42 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Sep 27 07:46:17 2020
 // Update Count     : 13
+// Last Modified On : Sat Jun  5 10:08:47 2021
+// Update Count     : 14
 //
 …
 //Dummy main
 int main( int argc, char const * argv[] ) {
+        #pragma message( "Compiled" )                                           // force non-empty .expect file
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+}

tests/warnings/.expect/self-assignment.nast.txt

-              r82f4063
+              rbae0d35
+warnings/self-assignment.cfa:34:25: warning: Compiled
 warnings/self-assignment.cfa:29:1 warning: self assignment of expression: Generated Cast of:
   Variable Expression: j: signed int
 …
 ... with resolved type:
   reference to signed int
-warnings/self-assignment.cfa: In function '_X4mainFi___1':
-warnings/self-assignment.cfa:36:9: note: #pragma message: Compiled

tests/warnings/self-assignment.cfa

-              r82f4063
+              rbae0d35
 // Created On       : Thu Mar 1 13:53:57 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Sep 27 09:24:34 2020
 // Update Count     : 6
+// Last Modified On : Sat Jun  5 10:08:56 2021
+// Update Count     : 7
 //
 …
         t.s.i = t.s.i;
+        #pragma message( "Compiled" )                   // force non-empty .expect file
+    #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
+}

Context Navigation

Legend:

Download in other formats: