Changeset 45c43e5 for doc/papers/general/Paper.tex

Timestamp:

Feb 26, 2018, 12:49:55 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

eddb399

Parents:

17fc7a5 (diff), 2c39855 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

File:

• doc/papers/general/Paper.tex (modified) (12 diffs)

doc/papers/general/Paper.tex

@@ -41 +41 @@
 
 \newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
-\newcommand{\TODO}[1]{\textbf{TODO}: {\itshape #1}} % TODO included
-%\newcommand{\TODO}[1]{} % TODO elided
+%\newcommand{\TODO}[1]{\textbf{TODO}: {\itshape #1}} % TODO included
+\newcommand{\TODO}[1]{} % TODO elided
 
 % Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
@@ -117 +117 @@
                 _Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, _At, __attribute,
                 __attribute__, auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__,
-                __const, __const__, disable, dtype, enable, __extension__, fallthrough, fallthru,
+                __const, __const__, disable, dtype, enable, exception, __extension__, fallthrough, fallthru,
                 finally, forall, ftype, _Generic, _Imaginary, inline, __label__, lvalue, _Noreturn, one_t,
                 otype, restrict, _Static_assert, throw, throwResume, trait, try, ttype, typeof, __typeof,
@@ -261 +261 @@
 The macro wrapping the generic expression imposes some limitations; as an example, it could not implement the example above, because the variables @max@ would collide with the functions @max@. 
 Ergonomic limitations of @_Generic@ include the necessity to put a fixed list of supported types in a single place and manually dispatch to appropriate overloads, as well as possible namespace pollution from the functions dispatched to, which must all have distinct names.
+Though name-overloading removes a major use-case for @_Generic@ expressions, \CFA does implement @_Generic@ for backwards-compatibility purposes. \TODO{actually implement that}
 
 % http://fanf.livejournal.com/144696.html
@@ -1356 +1357 @@
 \subsection{Exception Handling}
 
-\CFA provides two forms of exception handling: \newterm{resumption} (fix-up) and \newterm{recovery} (see Figure~\ref{f:CFAExceptionHandling}).
+The following framework for \CFA exception handling is in place, excluding a run-time type information and dynamic casts.
+\CFA provides two forms of exception handling: \newterm{fix-up} and \newterm{recovery} (see Figure~\ref{f:CFAExceptionHandling}).
 Both mechanisms provide dynamic call to a handler using dynamic name-lookup, where fix-up has dynamic return and recovery has static return from the handler.
-\CFA restricts exception types to those defined by aggregate type @_Exception@.
+\CFA restricts exception types to those defined by aggregate type @exception@.
 The form of the raise dictates the set of handlers examined during propagation: \newterm{resumption propagation} (@resume@) only examines resumption handlers (@catchResume@); \newterm{terminating propagation} (@throw@) only examines termination handlers (@catch@).
 If @resume@ or @throw@ have no exception type, it is a reresume/rethrow, meaning the currently exception continues propagation.
-If there is no current exception, the reresume/rethrow results in an error.
+If there is no current exception, the reresume/rethrow results in a runtime error.
 
 \begin{figure}
@@ -1369 +1371 @@
 \multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Resumption}}       & \multicolumn{1}{c}{\textbf{Recovery}} \\
 \begin{cfa}
-`_Exception R { int fix; };`
+`exception R { int fix; };`
 void f() {
         R r;
         ... `resume( r );` ...
         ... r.fix // control does return here after handler
+}
 `try` {
         ... f(); ...
@@ -1382 +1385 @@
 &
 \begin{cfa}
-`_Exception T {};`
+`exception T {};`
 void f() {
 
         ... `throw( T{} );` ...
         // control does NOT return here after handler
+}
 `try` {
         ... f(); ...
@@ -1419 +1423 @@
         ... write( `datafile`, ... ); ...               $\C{// may throw IOError}$
         ... write( `logfile`, ... ); ...
-} catch ( IOError err; `err == datafile` ) { ... } $\C{// handle datafile error}$
-   catch ( IOError err; `err == logfile` ) { ... } $\C{// handle logfile error}$
+} catch ( IOError err; `err.file == datafile` ) { ... } $\C{// handle datafile error}$
+   catch ( IOError err; `err.file == logfile` ) { ... } $\C{// handle logfile error}$
    catch ( IOError err ) { ... }                        $\C{// handler error from other files}$
 \end{cfa}
@@ -1428 +1432 @@
 The resumption raise can specify an alternate stack on which to raise an exception, called a \newterm{nonlocal raise}:
 \begin{cfa}
-resume [ $\emph{exception-type}$ ] [ _At $\emph{alternate-stack}$ ] ;
-\end{cfa}
-The @_At@ clause raises the specified exception or the currently propagating exception (reresume) at another coroutine or task~\cite{Delisle18}.
+resume( $\emph{exception-type}$, $\emph{alternate-stack}$ )
+resume( $\emph{alternate-stack}$ )
+\end{cfa}
+These overloads of @resume@ raise the specified exception or the currently propagating exception (reresume) at another coroutine or task~\cite{Delisle18}.
 Nonlocal raise is restricted to resumption to provide the exception handler the greatest flexibility because processing the exception does not unwind its stack, allowing it to continue after the handle returns.
 
@@ -1621 +1626 @@
 \lstMakeShortInline@%
 \end{cquote}
-Specifiers must appear at the start of a \CFA routine declaration\footnote{\label{StorageClassSpecifier}.
+Specifiers must appear at the start of a \CFA routine declaration\footnote{\label{StorageClassSpecifier}
 The placement of a storage-class specifier other than at the beginning of the declaration specifiers in a declaration is an obsolescent feature.~\cite[\S~6.11.5(1)]{C11}}.
 
@@ -1676 +1681 @@
 * [ * int, int ] ( int ) jp;                            $\C{// pointer to routine returning pointer to int and int, with int parameter}$
 \end{cfa}
-Note, \emph{a routine name cannot be specified}:
+Note, a routine name cannot be specified:
 \begin{cfa}
 * [ int x ] f () fp;                                            $\C{// routine name "f" is disallowed}$
@@ -1984 +1989 @@
 
 In C, @0@ has the special property that it is the only ``false'' value; by the standard, any value which compares equal to @0@ is false, while any value that compares unequal to @0@ is true. 
-As such, an expression @x@ in any boolean context (such as the condition of an @if@ or @while@ statement, or the arguments to an @&&@, @||@, or ternary operator) can be rewritten as @x != 0@ without changing its semantics.
+As such, an expression @x@ in any boolean context (such as the condition of an @if@ or @while@ statement, or the arguments to @&&@, @||@, or @?:@) can be rewritten as @x != 0@ without changing its semantics.
 The operator overloading feature of \CFA provides a natural means to implement this truth value comparison for arbitrary types, but the C type system is not precise enough to distinguish an equality comparison with @0@ from an equality comparison with an arbitrary integer or pointer. 
-To provide this precision, \CFA introduces a new type @zero_t@ as type type of literal @0@ (somewhat analagous to @nullptr_t@ and @nullptr@ in \CCeleven); @zero_t@ can only take the value @0@, but has implicit conversions to the integer and pointer types so that standard C code involving @0@ continues to work properly. 
+To provide this precision, \CFA introduces a new type @zero_t@ as type type of literal @0@ (somewhat analagous to @nullptr_t@ and @nullptr@ in \CCeleven); @zero_t@ can only take the value @0@, but has implicit conversions to the integer and pointer types so that C code involving @0@ continues to work properly. 
 With this addition, the \CFA compiler rewrites @if (x)@ and similar expressions to @if ((x) != 0)@ or the appropriate analogue, and any type @T@ can be made ``truthy'' by defining an operator overload @int ?!=?(T, zero_t)@.
 \CC makes types truthy by adding a conversion to @bool@; prior to the addition of explicit cast operators in \CCeleven this approach had the pitfall of making truthy types transitively convertable to any numeric type; our design for \CFA avoids this issue.
@@ -2614 +2619 @@
 \section{Acknowledgments}
 
-The authors would like to recognize the design assistance of Glen Ditchfield, Richard Bilson, and Thierry Delisle on the features described in this paper, and thank Magnus Madsen and the three anonymous reviewers for valuable feedback.
+The authors would like to recognize the design assistance of Glen Ditchfield, Richard Bilson, and Thierry Delisle on the features described in this paper, and thank Magnus Madsen for feedback in the writing.
 %This work is supported in part by a corporate partnership with \grantsponsor{Huawei}{Huawei Ltd.}{http://www.huawei.com}, and Aaron Moss and Peter Buhr are funded by the \grantsponsor{Natural Sciences and Engineering Research Council} of Canada.
 % the first author's \grantsponsor{NSERC-PGS}{NSERC PGS D}{http://www.nserc-crsng.gc.ca/Students-Etudiants/PG-CS/BellandPostgrad-BelletSuperieures_eng.asp} scholarship.