Changeset 36e05a2

Timestamp:

Apr 3, 2017, 9:10:57 AM (8 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, resolv-new, with_gc

Children:

8396044, fc19129

Parents:

ea73caf

Message:

more squeezing of text to fit on first 3 pages

File:

• doc/generic_types/generic_types.tex (modified) (4 diffs)

doc/generic_types/generic_types.tex

@@ -133 +133 @@
 \item Extensions introduced by \CFA must be translated in the most efficient way possible.
 \end{enumerate}
-The purpose of these goals is to ensure that existing C code-bases can be converted to \CFA incrementally and with minimal effort, and that programmers who know C can productively generate \CFA code without training beyond the features they wish to employ. In its current implementation, \CFA is compiled by translating it to the GCC-dialect of C~\citep{GCCExtensions}, allowing it to leverage the portability and code optimizations provided by GCC, meeting goals (1)-(3).
+These goals ensure existing C code-bases can be converted to \CFA incrementally and with minimal effort, and C programmers can productively generate \CFA code without training beyond the features they wish to employ. In its current implementation, \CFA is compiled by translating it to the GCC-dialect of C~\citep{GCCExtensions}, allowing it to leverage the portability and code optimizations provided by GCC, meeting goals (1)-(3). Ultimately, a compiler is necessary for advanced features and optimal performance.
 
 \CFA has been previously extended with polymorphic functions and name overloading (including operator overloading) by \citet{Bilson03}, and deterministically-executed constructors and destructors by \citet{Schluntz17}. This paper describes how generic and tuple types are designed and implemented in \CFA in accordance with both the backward compatibility goals and existing features described above.
@@ -167 +167 @@
 \begin{lstlisting}
 forall( otype T `| { int ?<?( T, T ); }` )      $\C{// type assertion}$
-  void qsort( const T * arr, size_t dim );
+  void qsort( const T * arr, size_t size );
 forall( otype T `| { int ?<?( T, T ); }` )      $\C{// type assertion}$
-  T * bsearch( T key, const T * arr, size_t dim );
+  T * bsearch( T key, const T * arr, size_t size );
 double vals[10] = { /* 10 floating-point values */ };
 qsort( vals, 10 );                                                      $\C{// sort array}$
@@ -190 +190 @@
 but providing a type-safe \CFA overloaded wrapper.
 \begin{lstlisting}
-forall( otype T | { int ?<?( T, T ); } ) T * bsearch( T key, const T * arr, size_t dim ) {
+forall( otype 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, dim, sizeof(T), comp );
-}
-forall( otype T | { int ?<?( T, T ); } ) unsigned int bsearch( T key, const T * arr, size_t dim ) {
-        T *result = bsearch( key, arr, dim );   $\C{// call first version}$
-        return result ? result - arr : dim;             $\C{// pointer subtraction includes sizeof(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 ) {
+        T *result = bsearch( key, arr, size );  $\C{// call first version}$
+        return result ? result - arr : size;            $\C{// pointer subtraction includes sizeof(T)}$
 }
 double * val = bsearch( 5.0, vals, 10 );        $\C{// selection based on return type}$
@@ -262 +262 @@
 };
 forall( otype T | summable( T ) )
-  T sum( T a[$\,$], size_t dim ) {
-        T total = { 0 };                                                        $\C{// instantiate T from 0}$
-        for ( unsigned int i = 0; i < dim; i += 1 )
+  T sum( T a[$\,$], size_t size ) {
+        T total = { 0 };                                                $\C{// instantiate T from 0}$
+        for ( unsigned int i = 0; i < size; i += 1 )
                 total += a[i];                                          $\C{// select appropriate +}$
         return total;