Changeset c8ad5d9 for doc/papers/general/Paper.tex

Timestamp:

Apr 22, 2018, 9:49:50 AM (6 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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, with_gc

Children:

22bdc34, da7fe39

Parents:

58caf150

Message:

updates

File:

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

doc/papers/general/Paper.tex

@@ -1 @@
-\documentclass[AMA,STIX1COL,STIXSMALL]{WileyNJD-v2}
+\documentclass[AMA,STIX1COL]{WileyNJD-v2}
+
 \articletype{RESEARCH ARTICLE}%
 
@@ -17 +18 @@
 \usepackage{upquote}                                            % switch curled `'" to straight
 \usepackage{listings}                                           % format program code
+\captionsetup{justification=raggedright,singlelinecheck=false}
 %\usepackage{enumitem}
 %\setlist[itemize]{topsep=3pt,itemsep=2pt,parsep=0pt}% global
@@ -27 +29 @@
 \renewcommand{\linenumberfont}{\scriptsize\sffamily}
 
-\lefthyphenmin=4                                                        % hyphen only after 4 characters
-\righthyphenmin=4
+\lefthyphenmin=3                                                        % hyphen only after 4 characters
+\righthyphenmin=3
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -86 +88 @@
 \newcommand{\abbrevFont}{\textit}                       % set empty for no italics
 \@ifundefined{eg}{
-\newcommand{\EG}{\abbrevFont{e}.\abbrevFont{g}.}
+\newcommand{\EG}{\abbrevFont{e}\abbrevFont{g}}
 \newcommand*{\eg}{%
         \@ifnextchar{,}{\EG}%
@@ -93 +95 @@
 }}{}%
 \@ifundefined{ie}{
-\newcommand{\IE}{\abbrevFont{i}.\abbrevFont{e}.}
+\newcommand{\IE}{\abbrevFont{i}\abbrevFont{e}}
 \newcommand*{\ie}{%
         \@ifnextchar{,}{\IE}%
@@ -129 +131 @@
 \lstdefinelanguage{CFA}[ANSI]{C}{
         morekeywords={
-                _Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, _At, __attribute,
-                __attribute__, auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__,
-                __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,
-                __typeof__, virtual, with, zero_t},
-        morekeywords=[2]{
-                _Atomic, coroutine, is_coroutine, is_monitor, is_thread, monitor, mutex, nomutex, or,
-                resume, suspend, thread, _Thread_local, waitfor, when, yield},
+                _Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, __attribute, __attribute__,
+                auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__, __const, __const__,
+                coroutine, disable, dtype, enable, exception, __extension__, fallthrough, fallthru, finally,
+                __float80, float80, __float128, float128, forall, ftype, _Generic, _Imaginary, __imag, __imag__,
+                inline, __inline, __inline__, __int128, int128, __label__, monitor, mutex, _Noreturn, one_t, or,
+                otype, restrict, __restrict, __restrict__, __signed, __signed__, _Static_assert, thread,
+                _Thread_local, throw, throwResume, timeout, trait, try, ttype, typeof, __typeof, __typeof__,
+                virtual, __volatile, __volatile__, waitfor, when, with, zero_t},
         moredirectives={defined,include_next}%
 }
@@ -158 +159 @@
 literate={-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.1ex}}}}1 {^}{\raisebox{0.6ex}{$\scriptstyle\land\,$}}1
         {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 % {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
-        {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {->}{\makebox[1ex][c]{\raisebox{0.5ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex{\textgreater}}2,
+        {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {->}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex{\textgreater}}2,
 moredelim=**[is][\color{red}]{`}{`},
 }% lstset
@@ -180 +181 @@
 \authormark{MOSS \textsc{et al}}
 
-\address[1]{\orgdiv{David R. Cheriton School of Computer Science}, \orgname{University of Waterloo}, \orgaddress{\state{Ontario}, \country{Canada}}}
-
-\corres{*Peter A. Buhr, \email{pabuhr{\char`\@}uwaterloo.ca}}
-\presentaddress{David R. Cheriton School of Computer Science, University of Waterloo, Waterloo, ON, N2L 3G1, Canada}
-
+\address[1]{\orgdiv{Cheriton School of Computer Science}, \orgname{University of Waterloo}, \orgaddress{\state{Waterloo, ON}, \country{Canada}}}
+
+\corres{*Peter A. Buhr, Cheriton School of Computer Science, University of Waterloo, 200 University Avenue West, Waterloo, ON, N2L 3G1, Canada. \email{pabuhr{\char`\@}uwaterloo.ca}}
+
+\fundingInfo{Natural Sciences and Engineering Research Council of Canada}
 
 \abstract[Summary]{
@@ -228 +229 @@
 Nevertheless, C, first standardized over thirty years ago, lacks many features that make programming in more modern languages safer and more productive.
 
-\CFA (pronounced ``C-for-all'', and written \CFA or Cforall) is an evolutionary extension of the C programming language that aims to add modern language features to C while maintaining both source compatibility with C and a familiar programming model for programmers.
+\CFA (pronounced ``C-for-all'', and written \CFA or Cforall) is an evolutionary extension of the C programming language that aims to add modern language features to C, while maintaining both source and runtime compatibility with C and a familiar programming model for programmers.
 The four key design goals for \CFA~\cite{Bilson03} are:
 (1) The behaviour of standard C code must remain the same when translated by a \CFA compiler as when translated by a C compiler;
@@ -328 +329 @@
 A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted float array:
 \begin{cfa}
-void * bsearch( const void * key, const void * base, size_t nmemb, size_t size,
-                                         int (* compar)( const void *, const void * ));
+void * bsearch( const void * key, const void * base, size_t nmemb, size_t size, int (* compar)( const void *, const void * ));
 int comp( const void * t1, const void * t2 ) {
          return *(double *)t1 < *(double *)t2 ? -1 : *(double *)t2 < *(double *)t1 ? 1 : 0;
@@ -336 +336 @@
 double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); $\C{// search sorted array}$
 \end{cfa}
-which can be augmented simply with a generalized, type-safe, \CFA-overloaded wrappers:
+which can be augmented simply with generalized, type-safe, \CFA-overloaded wrappers:
 \begin{cfa}
 forall( otype T | { int ?<?( T, T ); } ) T * bsearch( T key, const T * arr, size_t size ) {
@@ -398 +398 @@
         T ?++( T * );
 };
-forall( otype T `| summable( T )` ) T sum( T a[$\,$], size_t size ) {  // use trait
+forall( otype T `| summable( T )` ) T sum( T a[$\,$], size_t size ) {$\C{// use trait}$
         `T` total = { `0` };                                    $\C{// instantiate T from 0 by calling its constructor}$
         for ( unsigned int i = 0; i < size; i += 1 ) total `+=` a[i]; $\C{// select appropriate +}$
@@ -576 +576 @@
         return (scalar(U)){ a.value + b.value };
 }
-scalar(metres) half_marathon = { 21093 };
-scalar(litres) swimming_pool = { 2500000 };
+scalar(metres) half_marathon = { 21_093 };
+scalar(litres) swimming_pool = { 2_500_000 };
 scalar(metres) marathon = half_marathon + half_marathon;
 scalar(litres) two_pools = swimming_pool + swimming_pool;
@@ -724 +724 @@
 \end{cfa}
 Here, the mass assignment sets all members of @s@ to zero.
-Since tuple-index expressions are a form of member-access expression, it is possible to use tuple-index expressions in conjunction with member tuple expressions to manually restructure a tuple (\eg rearrange, drop, and duplicate components).
+Since tuple-index expressions are a form of member-access expression, it is possible to use tuple-index expressions in conjunction with member-tuple expressions to manually restructure a tuple (\eg rearrange, drop, and duplicate components).
 \begin{cfa}
 [int, int, long, double] x;
@@ -1879 +1879 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{3em}}l|l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C Type Nesting}}      & \multicolumn{1}{c}{\textbf{C Implicit Hoisting}}      & \multicolumn{1}{|c}{\textbf{\CFA}}    \\
+\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C Type Nesting}}      & \multicolumn{1}{c|}{\textbf{C Implicit Hoisting}}     & \multicolumn{1}{c}{\textbf{\CFA}}     \\
 \hline
 \begin{cfa}
@@ -2002 +2002 @@
 {
         VLA  x,            y = { 20, 0x01 },     z = y; $\C{// z points to y}$
-        //    ?{}( x );   ?{}( y, 20, 0x01 );    ?{}( z, y ); 
+        //      ?{}( x );   ?{}( y, 20, 0x01 );   ?{}( z, y ); 
         ^x{};                                                                   $\C{// deallocate x}$
         x{};                                                                    $\C{// reallocate x}$
@@ -2027 +2027 @@
 These semantics closely mirror the rule for implicit declaration of constructors in \CC\cite[p.~186]{ANSI98:C++}.
 
-In some circumstance programmers may not wish to have constructor and destructor calls.
-In these cases, \CFA provides the initialization syntax \lstinline|S x @= {}|, and the object becomes unmanaged, so implicit constructor and destructor calls are not generated. 
-Any C initializer can be the right-hand side of an \lstinline|@=| initializer, \eg \lstinline|VLA a @= { 0, 0x0 }|, with the usual C initialization semantics. 
+In some circumstance programmers may not wish to have implicit constructor and destructor generation and calls.
+In these cases, \CFA provides the initialization syntax \lstinline|S x `@=` {}|, and the object becomes unmanaged, so implicit constructor and destructor calls are not generated. 
+Any C initializer can be the right-hand side of an \lstinline|@=| initializer, \eg \lstinline|VLA a @= { 0, 0x0 }|, with the usual C initialization semantics.
+The same syntax can be used in a compound literal, \eg \lstinline|a = VLA`@`{ 0, 0x0 }|, to create a C-style literal.
 The point of \lstinline|@=| is to provide a migration path from legacy C code to \CFA, by providing a mechanism to incrementally convert to implicit initialization.
 
@@ -2054 +2055 @@
 \begin{cfa}
 20_`hh`     // signed char
-21_`hh`u    // unsigned char
+21_`hh`u   // unsigned char
 22_`h`       // signed short int
 23_u`h`     // unsigned short int
-24`z`       // size_t
+24`z`         // size_t
 \end{cfa}
 &
@@ -2088 +2089 @@
 To provide this precision, \CFA introduces a new type @zero_t@ as the 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. 
-With this addition, \CFA rewrites @if (x)@ and similar expressions to @if ((x) != 0)@ or the appropriate analogue, and any type @T@ is ``truthy'' by defining an operator overload @int ?!=?(T, zero_t)@.
+With this addition, \CFA rewrites @if (x)@ and similar expressions to @if ( (x) != 0 )@ or the appropriate analogue, and any type @T@ is ``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;
@@ -2163 +2164 @@
 \lstset{language=CFA,moredelim=**[is][\color{red}]{|}{|},deletedelim=**[is][]{`}{`}}
 \lstDeleteShortInline@%
-\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}     & \multicolumn{1}{c}{\textbf{\CC}}      \\
+\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}    & \multicolumn{1}{c}{\textbf{\CC}}      \\
 \begin{cfa}
 struct W {
@@ -2260 +2261 @@
 \begin{cfa}
 MIN
-
 MAX
-
 PI
 E
@@ -2268 +2267 @@
 &
 \begin{cfa}
-SCHAR_MIN, CHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN,
-                FLT_MIN, DBL_MIN, LDBL_MIN
-SCHAR_MAX, UCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX,
-                FLT_MAX, DBL_MAX, LDBL_MAX
+SCHAR_MIN, CHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN, FLT_MIN, DBL_MIN, LDBL_MIN
+SCHAR_MAX, UCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX, FLT_MAX, DBL_MAX, LDBL_MAX
 M_PI, M_PIl
 M_E, M_El
@@ -2444 +2441 @@
 ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) );
 ip = (int *)realloc( ip, 2 * dim * sizeof( int ) );
-ip = (int *)realloc( ip, 4 * dim * sizeof( int ) );
-                        memset( ip, fill, 4 * dim * sizeof( int ) );
+ip = (int *)realloc( ip, 4 * dim * sizeof( int ) ); memset( ip, fill, 4 * dim * sizeof( int ) );
+
 ip = memalign( 16, sizeof( int ) );
 ip = memalign( 16, sizeof( int ) ); memset( ip, fill, sizeof( int ) );