Changeset b5563e1 for doc/papers/general

Timestamp:

Mar 27, 2018, 10:21:32 AM (8 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, with_gc

Children:

3d2b7bc

Parents:

a9b1b0c (diff), af1ed1ad (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) (9 diffs)

doc/papers/general/Paper.tex

@@ -671 +671 @@
 \begin{cfa}
 int f( int, int );
-int g( [int, int] );
-int h( int, [int, int] );
+[int] g( [int, int] );
+[int] h( int, [int, int] );
 [int, int] x;
 int y;
@@ -706 +706 @@
 This example shows mass, multiple, and cascading assignment used in one expression:
 \begin{cfa}
-void f( [int, int] );
+[void] f( [int, int] );
 f( [x, y] = z = 1.5 );                                          $\C{// assignments in parameter list}$
 \end{cfa}
@@ -814 +814 @@
 Flattening and restructuring conversions are also applied to tuple types in polymorphic type assertions.
 \begin{cfa}
-int f( [int, double], double );
+[int] f( [int, double], double );
 forall( otype T, otype U | { T f( T, U, U ); } ) void g( T, U );
 g( 5, 10.21 );
@@ -1152 +1152 @@
   case 4:
         ... `fallthrough common;`
-  common: // below fallthrough at same level as case clauses
+  `common`: // below fallthrough at same level as case clauses
         ...      // common code for cases 3 and 4
         // implicit break
@@ -1857 +1857 @@
 \begin{cfa}
 struct S { double x, y; };
-int i, j;
+int x, y;
 void f( int & i, int & j, S & s, int v[] );
-f( 3, i + j, (S){ 1.0, 7.0 }, (int [3]){ 1, 2, 3 } );   $\C{// pass rvalue to lvalue \(\Rightarrow\) implicit temporary}$
+f( 3, x + y, (S){ 1.0, 7.0 }, (int [3]){ 1, 2, 3 } ); $\C{// pass rvalue to lvalue \(\Rightarrow\) implicit temporary}$
 \end{cfa}
 This allows complex values to be succinctly and efficiently passed to functions, without the syntactic overhead of explicit definition of a temporary variable or the runtime cost of pass-by-value.
@@ -1946 +1946 @@
 
 One of the strengths (and weaknesses) of C is memory-management control, allowing resource release to be precisely specified versus unknown release with garbage-collected memory-management.
-However, this manual approach is often verbose, and it is useful to manage resources other than memory (\eg file handles) using the same mechanism as memory.
+However, this manual approach is verbose, and it is useful to manage resources other than memory (\eg file handles) using the same mechanism as memory.
 \CC addresses these issues using Resource Aquisition Is Initialization (RAII), implemented by means of \newterm{constructor} and \newterm{destructor} functions;
 \CFA adopts constructors and destructors (and @finally@) to facilitate RAII.
@@ -1998 +1998 @@
 {
         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}$
@@ -2099 +2099 @@
 
 For readability, it is useful to associate units to scale literals, \eg weight (stone, pound, kilogram) or time (seconds, minutes, hours).
-The left of Figure~\ref{f:UserLiteral} shows the \CFA alternative call-syntax (literal argument before function name), using the backquote, to convert basic literals into user literals.
+The left of Figure~\ref{f:UserLiteral} shows the \CFA alternative call-syntax (postfix: literal argument before function name), using the backquote, to convert basic literals into user literals.
 The backquote is a small character, making the unit (function name) predominate.
 For examples, the multi-precision integer-type in Section~\ref{s:MultiPrecisionIntegers} has user literals:
@@ -2107 +2107 @@
 y = "12345678901234567890123456789"|`mp| + "12345678901234567890123456789"|`mp|;
 \end{cfa}
-Because \CFA uses a standard function, all types and literals are applicable, as well as overloading and conversions.
+Because \CFA uses a standard function, all types and literals are applicable, as well as overloading and conversions, where @?`@ denotes a postfix-function name and @`@ denotes a postfix-function call.
 }%
+\begin{cquote}
+\lstset{language=CFA,moredelim=**[is][\color{red}]{|}{|},deletedelim=**[is][]{`}{`}}
+\lstDeleteShortInline@%
+\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{\hspace{2\parindentlnth}}l@{\hspace{2\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{postfix function}}        & \multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{constant}}      & \multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{variable/expression}}   & \multicolumn{1}{c}{\textbf{postfix pointer}}  \\
+\begin{cfa}
+int ?`h( int s );
+int ?`h( double s );
+int ?`m( char c );
+int ?`m( const char * s );
+int ?`t( int a, int b, int c );
+\end{cfa}
+&
+\begin{cfa}
+0 `h;
+3.5`h;
+'1'`m;
+"123" "456"`m;
+[1,2,3]`t;
+\end{cfa}
+&
+\begin{cfa}
+int i = 7;
+i`h;
+(i + 3)`h;
+(i + 3.5)`h;
+
+\end{cfa}
+&
+\begin{cfa}
+int (* ?`p)( int i );
+?`p = ?`h;
+3`p;
+i`p;
+(i + 3)`p;
+\end{cfa}
+\end{tabular}
+\lstMakeShortInline@%
+\end{cquote}
 
 The right of Figure~\ref{f:UserLiteral} shows the equivalent \CC version using the underscore for the call-syntax.