Changeset 59c034c6

Timestamp:

May 23, 2018, 8:59:45 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:

6f9bc09, b9da9585

Parents:

2c88368

Message:

small updates

File:

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

doc/papers/general/Paper.tex

@@ -243 +243 @@
 Nevertheless, C, first standardized almost forty years ago~\cite{ANSI89:C}, 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 adds modern language-features to C, while maintaining both source and runtime 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 adds modern language-features to C, while maintaining source and runtime compatibility in the familiar C programming model.
 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;
@@ -273 +273 @@
 Starting with a translator versus a compiler makes it easier and faster to generate and debug C object-code rather than intermediate, assembler or machine code.
 The translator design is based on the \emph{visitor pattern}, allowing multiple passes over the abstract code-tree, which works well for incrementally adding new feature through additional visitor passes.
-At the heart of the translator is the type resolver, which handles the polymorphic routine/type overload-resolution.
+At the heart of the translator is the type resolver, which handles the polymorphic function/type overload-resolution.
 % @plg2[8]% cd cfa-cc/src; cloc libcfa
 % -------------------------------------------------------------------------------
@@ -310 +310 @@
 
 Finally, it is impossible to describe a programming language without usages before definitions.
-Therefore, syntax and semantics appear before explanations;
-hence, patience is necessary until details are presented.
+Therefore, syntax and semantics appear before explanations, and related work (Section~\ref{s:RelatedWork}) is deferred until \CFA is presented;
+hence, patience is necessary until details are discussed.
 
 
@@ -329 +329 @@
 \end{quote}
 \vspace{-9pt}
-C already has a limited form of ad-hoc polymorphism in the form of its basic arithmetic operators, which apply to a variety of different types using identical syntax. 
+C already has a limited form of ad-hoc polymorphism in its basic arithmetic operators, which apply to a variety of different types using identical syntax. 
 \CFA extends the built-in operator overloading by allowing users to define overloads for any function, not just operators, and even any variable;
 Section~\ref{sec:libraries} includes a number of examples of how this overloading simplifies \CFA programming relative to C. 
@@ -1535 +1535 @@
 The difference between parallel and nesting occurs for fields with the same name and type:
 \begin{cfa}
-struct S { int `i`; int j; double m; } s, w;
+struct S { int `i`; int j; double m; } s, w;    $\C{// field i has same type in structure types S and T}$
 struct T { int `i`; int k; int m; } t, w;
-with ( s, t ) {
+with ( s, t ) {                                                         $\C{// open structure variables s and t in parallel}$
         j + k;                                                                  $\C{// unambiguous, s.j + t.k}$
         m = 5.0;                                                                $\C{// unambiguous, s.m = 5.0}$
@@ -2005 +2005 @@
 Destruction parameters are useful for specifying storage-management actions, such as de-initialize but not deallocate.}.
 \begin{cfa}
-struct VLA { int len, * data; };                        $\C{// variable length array of integers}$
-void ?{}( VLA & vla ) with ( vla ) { len = 10;  data = alloc( len ); }  $\C{// default constructor}$
+struct VLA { int size, * data; };                       $\C{// variable length array of integers}$
+void ?{}( VLA & vla ) with ( vla ) { size = 10;  data = alloc( size ); }  $\C{// default constructor}$
 void ^?{}( VLA & vla ) with ( vla ) { free( data ); } $\C{// destructor}$
 {
@@ -2019 +2019 @@
 \CFA also provides syntax for \newterm{initialization} and \newterm{copy}:
 \begin{cfa}
-void ?{}( VLA & vla, int size, char fill ) with ( vla ) {  $\C{// initialization}$
-        len = size;  data = alloc( len, fill );
+void ?{}( VLA & vla, int size, char fill = '\0' ) {  $\C{// initialization}$
+        vla.[ size, data ] = [ size, alloc( size, fill ) ];
 }
 void ?{}( VLA & vla, VLA other ) {                      $\C{// copy, shallow}$
-        vla.len = other.len;  vla.data = other.data;
+        vla = other;
 }
 \end{cfa}
@@ -2048 +2048 @@
         y{ x };                                                                 $\C{// reallocate y, points to x}$
         x{};                                                                    $\C{// reallocate x, not pointing to y}$
-        //  ^z{};  ^y{};  ^x{};
-}
+}       //  ^z{};  ^y{};  ^x{};
 \end{cfa}
 
@@ -2740 +2739 @@
 
 \section{Related Work}
+\label{s:RelatedWork}