Context Navigation

← Previous Changeset
Next Changeset →

Changeset bab42de

Timestamp:

Apr 23, 2024, 3:55:44 PM (7 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

03b1815

Parents:

89da3a9 (diff), 5bc81e9 (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:software/cfa/cfa-cc

File:

: 1 edited

doc/user/user.tex (modified) (29 diffs)

Legend:

: Unmodified
: Added
: Removed

doc/user/user.tex

-                      r89da3a9
+                      rbab42de
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Thu Apr 18 21:53:45 2024
 %% Update Count     : 6502
+%% Last Modified On : Tue Apr 23 14:13:10 2024
+%% Update Count     : 6623
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \lstset{language=CFA}                                                                   % CFA default lnaguage
 \lstnewenvironment{C++}[1][]                            % use C++ style
 {\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®},#1}}
+{\lstset{language=C++,escapechar=§,moredelim=**[is][\protect\color{red}]{®}{®},#1}}
 {}
 …
 Since the strings overlap starting with the open bracket, ©[©, there is an ambiguous interpretation for the string.
-{\color{red}
 As well, \CFA-style declarations cannot be used to declare parameters for C-style routine-definitions because of the following ambiguity:
 \begin{cfa}
 …
 int f( int (* foo) ); §\C{// foo is redefined as a parameter name}§
 \end{cfa}
 The string ``©int (* foo)©'' declares a C-style named-parameter of type pointer to an integer (the parenthesis are superfluous), while the same string declares a \CFA style unnamed parameter of type routine returning integer with unnamed parameter of type pointer to foo.
+The string ``©int (* foo)©'' declares a C-style named-parameter of type pointer to an integer (the parenthesis are superfluous), while the same string declares a \CFA style unnamed parameter of type routine returning integer with unnamed parameter of type pointer to ©foo©.
 The redefinition of a type name in a parameter list is the only context in C where the character ©*© can appear to the left of a type name, and \CFA relies on all type qualifier characters appearing to the right of the type name.
 The inability to use \CFA declarations in these two contexts is probably a blessing because it precludes programmers from arbitrarily switching between declarations forms within a declaration contexts.}
+The inability to use \CFA declarations in these two contexts is probably a blessing because it precludes programmers from arbitrarily switching between declarations forms within a declaration contexts.
 C-style declarations can be used to declare parameters for \CFA style routine definitions, \eg:
 …
 \subsection{Postfix Function}
 \label{s:PostfixFunction}
+\index{postfix function}
 \CFA provides an alternative call syntax where the argument appears before the function name.
 …
 '1'`m;
 "123" "456"`m;
 [1,2,3]`t;
+[1, 2, 3]`t;
 \end{cfa}
+&
 …
 \end{tabular}
 \end{cquote}
+Note, to pass \emph{multiple} arguments to a postfix function requires a \Index{tuple}, \eg ©[1, 2, 3]`t©, which forms a single argument that is flattened into the multiple arguments \see{\VRef{s:Tuple}}.
+Similarly, if the argument is an expression, it must be parenthesized, \eg ©(i + 3)`h©, or only the last operand of the expression is the argument, \eg ©i + (3`h)©.
 \VRef[Figure]{f:UnitsComparison} shows a common usage for postfix functions: converting basic literals into user literals.
 …
         return l.stones + r.stones;
+}
 Weight ?`st( double w ) { return w; }
 double ?`st( Weight w ) { return w.stones; }
 Weight ?`lb( double w ) { return w / 14.0; }
 double ?`lb( Weight w ) { return w.stones * 14.0; }
 Weight ?`kg( double w ) { return w / 6.35; }
 double ?`kg( Weight w ) { return w.stones * 6.35; }
+Weight ®?`st®( double w ) { return w; }
+double ®?`st®( Weight w ) { return w.stones; }
+Weight ®?`lb®( double w ) { return w / 14.0; }
+double ®?`lb®( Weight w ) { return w.stones * 14.0; }
+Weight ®?`kg®( double w ) { return w / 6.35; }
+double ®?`kg®( Weight w ) { return w.stones * 6.35; }
 int main() {
         Weight w, heavy = { 20 }; // stones
         w = 155`lb;
         w = 0b_1111`st;
         w = 0_233`lb;
         w = 0x_9b`kg;
         w = 5.5`st + 8`kg + 25.01`lb + heavy;
+        w = 155®`lb®;
+        w = 0b_1111®`st®;
+        w = 0_233®`lb®;
+        w = 0x_9b®`kg®;
+        w = 5.5®`st® + 8®`kg® + 25.01®`lb® + heavy;
+}
 \end{cfa}
 …
         return l.stones + r.stones;
+}
 Weight operator""_st( long double w ) { return w; }
 Weight operator""_lb( long double w ) { return w / 14.0; }
 Weight operator""_kg( long double w ) { return w / 6.35; }
 Weight operator""_st( unsigned long long int w ) { return w; }
 Weight operator""_lb( unsigned long long int w ) { return w / 14.0; }
 Weight operator""_kg( unsigned long long int w ) { return w / 6.35; }
+Weight operator®""_st®( long double w ) { return w; }
+Weight operator®""_lb®( long double w ) { return w / 14.0; }
+Weight operator®""_kg®( long double w ) { return w / 6.35; }
+Weight operator®""_st®( unsigned long long int w ) { return w; }
+Weight operator®""_lb®( unsigned long long int w ) { return w / 14.0; }
+Weight operator®""_kg®( unsigned long long int w ) { return w / 6.35; }
 int main() {
         Weight w, heavy = { 20 }; // stones
         w = 155_lb;
         w = 0b1111_st;
         w = 0'233_lb;           // quote separator
         w = 0x9b_kg;
         w = 5.5_st + 8_kg + 25.01_lb + heavy;
+        w = 155®_lb®;
+        w = 0b1111®_st®;
+        w = 0'233®_lb®;         // quote separator
+        w = 0x9b®_kg®;
+        w = 5.5®_st® + 8®_kg® + 25.01®_lb® + heavy;
+}
 \end{C++}
 …
 \section{Tuple}
+\label{s:Tuple}
 In C and \CFA, lists of elements appear in several contexts, such as the parameter list of a routine call.
 …
 [ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = §\emph{expr}§;
 \end{cfa}
+\index{lvalue}
+The left-hand side is a tuple of \LstBasicStyle{\emph{lvalues}}, which is a list of expressions each yielding an address, \ie any data object that can appear on the left-hand side of a conventional assignment statement.
+The left-hand side is a tuple of \LstBasicStyle{\emph{\Index{lvalue}}}s, which is a list of expressions each yielding an address, \ie any data object that can appear on the left-hand side of a conventional assignment statement.
 \LstBasicStyle{\emph{expr}} is any standard arithmetic expression.
 Clearly, the types of the entities being assigned must be type compatible with the value of the expression.
 …
 Multiple assignment has the following form:
 \begin{cfa}
+[ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = [ §\emph{expr}§, ... , §\emph{expr}§ ];
+\end{cfa}
+\index{lvalue}
+The left-hand side is a tuple of \emph{lvalues}, and the right-hand side is a tuple of \emph{expr}s.
+Each \emph{expr} appearing on the right-hand side of a multiple assignment statement is assigned to the corresponding \emph{lvalues} on the left-hand side of the statement using parallel semantics for each assignment.
+[ §\emph{lvalue}§, ... , §\emph{lvalue}§ ] = [ §\emph{expr}§, ... , §\emph{expr}§ ];§
+\end{cfa}
+The left-hand side is a tuple of \LstBasicStyle{\emph{\Index{lvalue}}}s, and the right-hand side is a tuple of \LstBasicStyle{\emph{expr}}s.
+Each \LstBasicStyle{\emph{expr}} appearing on the right-hand side of a multiple assignment statement is assigned to the corresponding \LstBasicStyle{\emph{lvalues}} on the left-hand side of the statement using parallel semantics for each assignment.
 An example of multiple assignment is:
 \begin{cfa}
 …
 \section{Standard Library}
 \label{s:StandardLibrary}
+\index{standard library}
 The \CFA standard-library extends existing C library routines by adding new function, wrapping existing explicitly-polymorphic C routines into implicitly-polymorphic versions, and adding new \CFA extensions.
 …
 \subsection{Dynamic Storage-Management}
 \label{s:DynamicStorageManagement}
+\index{dynamic storage-management}\index{storage management}
 Dynamic storage-management in C is based on explicit allocation and deallocation (©malloc©/©free©).
 …
 \begin{enumerate}[leftmargin=\parindent]
 \item
 Extend type safety of all allocation routines by using the left-hand assignment type to determine the allocation size and alignment, and return a matching type for the new storage, which removes many common allocation errors.
+extends type safety of all allocation routines by using the left-hand assignment type to determine the allocation size and alignment, and return a matching type for the new storage, which removes many common allocation errors.
 \begin{cfa}
 int * ip = (int *)malloc( sizeof(int) ); §\C[2.3in]{// C}§
 int * ip = malloc();                                    §\C{// \CFA type-safe call of C malloc}§
 int * ip = alloc();                                             §\C{// \CFA type-safe call of \CFA alloc}§
 struct __attribute__(( aligned(128) )) spinlock { ... };
+int * ip = calloc();                                    §\C{// \CFA type-safe call of C calloc}§
+struct __attribute__(( aligned(128) )) spinlock { ... }; // cache alignment
 spinlock * slp = malloc();                              §\C{// correct size, alignment, and return type}\CRT§
 \end{cfa}
 …
 \item
 Introduce the notion of \newterm{sticky properties} used in resizing.
+introduces the notion of \newterm{sticky properties} used in resizing.
 All initial allocation properties are remembered and maintained for use should resize require new storage.
 For example, the initial alignment and fill properties in the initial allocation
 …
 \item
 Provide resizing without data copying, which is useful to repurpose an existing block of storage for another purpose, rather than freeing the old storage and performing a new allocation.
 The resize might be able to take advantage of unused storage after the data to preventing the free/reallocation step altogether.
 \item
 Provide ©free©/©delete© functions that delete a variable number of pointers.
+provides resizing without data copying, which is useful to repurpose an existing block of storage, rather than freeing the old storage and performing a new allocation.
+A resize can take advantage of unused storage after the data to preventing a free/reallocation step altogether.
+\item
+provides ©free©/©delete© functions that delete a variable number of allocations.
 \begin{cfa}
 int * ip = malloc(), * jp = malloc(), * kp = malloc();
 double * xp = malloc(), * yp = malloc(), * zp = malloc();
 free( ®ip, jp, kp, xp, yp, zp® );
 \end{cfa}
 \item
 Support constructors for initialization of allocated storage (like \CC) and destructors for deallocation.
+free( ®ip, jp, kp, xp, yp, zp® );               §\C{// multiple deallocations}§
+\end{cfa}
+\item
+supports constructors for initialization of allocated storage and destructors for deallocation (like \CC).
 \begin{cfa}
 struct S { int v; };                                    §\C{// default constructors}§
 …
 Allocation routines ©new©/©anew© allocate a variable/array and initialize storage using the allocated type's constructor.
 Note, the matching deallocation routines ©delete©/©adelete©.
+\CC only supports the default constructor for intializing array elements.
+\begin{C++}
+S * sp = new S[10]®{5}®;                                §\C{// disallowed}§
+\end{C++}
 \end{enumerate}
 …
 \end{enumerate}
+The polymorphic functions ©T * alloc( ... )© and ©T * alloc( size_t dim, ... )© are overloaded with a variable number of specific allocation properties, or an integer dimension parameter followed by a variable number of specific allocation properties.
+These allocation properties can be passed as named arguments when calling the \lstinline{alloc} routine.
+A call without parameters returns an uninitialized dynamically allocated object of type ©T© (©malloc©).
+A call with only the dimension (dim) parameter returns an uninitialized dynamically allocated array of objects with type ©T© (©aalloc©).
+The variable number of arguments consist of allocation properties, which can be combined to produce different kinds of allocations.
+The properties ©resize© and ©realloc© are associated with the allocation variable indicating how the existing allocation is modified, without or with data copying.
+Function ©alloc© is used extensively in the \CFA runtime.
+The polymorphic functions
+\begin{cfa}
+T * alloc( ... );
+T * alloc( size_t dim, ... );
+\end{cfa}
+are overloaded with a variable number of allocation properties.
+These allocation properties can be passed as named arguments when calling the \Indexc{alloc} routine.
+A call without parameters returns an uninitialized dynamically allocated object of type ©T© (\Indexc{malloc}).
+A call with only the dimension (dim) parameter returns an uninitialized dynamically allocated array of objects with type ©T© (\Indexc{aalloc}).
+The variable number of arguments consist of allocation properties to specialize the allocation.
+The properties ©resize© and ©realloc© are associated with an existing allocation variable indicating how its storage is modified.
 The following allocation property functions may be combined and appear in any order as arguments to ©alloc©,
 …
 \item
 ©T_align ?`align( size_t alignment )© to align an allocation.
 The alignment parameter must be $\ge$ the default alignment (©libAlign()© in \CFA) and a power of two, \eg:
 \begin{cfa}
 int * i0 = alloc( ®4096`align® );  sout | i0 | nl;
 int * i1 = alloc( 3, ®4096`align® );  sout | i1; for (i; 3 ) sout | &i1[i] | nonl; sout | nl;
+x555555572000
 x555555574000 0x555555574000 0x555555574004 0x555555574008
+\end{cfa}
+returns a dynamic object and object array aligned on a 4096-byte boundary.
 \item
 ©S_fill(T) ?`fill ( /* various types */ )© to initialize storage.
+The alignment parameter must be $\ge$ the default alignment (©libAlign()© in \CFA) and a power of two, \eg the following return a dynamic object and object array aligned on a 256 and 4096-byte boundary.
+\begin{cfa}
+int * i0 = alloc( ®256`align® );  sout | i0 | nl;
+int * i1 = alloc( 3, ®4096`align® );  for (i; 3 ) sout | &i1[i] | nonl;  sout | nl;
+free( i0, i1 );
+x5555565699®00®  // 256 alignment
+x55555656c®000® 0x5656c004 0x5656c008  // 4K array alignment
+\end{cfa}
+\item
+©T_fill(T) ?`fill( /* various types */ )© to initialize storage.
 There are three ways to fill storage:
 \begin{enumerate}
 …
 For example:
 \begin{cfa}[numbers=left]
 int * i0 = alloc( ®0n`fill® );  sout | *i0 | nl;  // 0n disambiguates 0
+int * i0 = alloc( ®0n`fill® );  sout | *i0 | nl;  // 0n disambiguates 0p
 int * i1 = alloc( ®5`fill® );  sout | *i1 | nl;
 int * i2 = alloc( ®'\xfe'`fill® ); sout | hex( *i2 ) | nl;
 …
 int * i5 = alloc( 5, ®i3`fill® );  for ( i; 5 ) sout | i5[i] | nonl; sout | nl; // completely fill from i3
 int * i6 = alloc( 5, ®[i3, 3]`fill® );  for ( i; 5 ) sout | i6[i] | nonl; sout | nl; // partial fill from i3
+free( i0, i1, i2, i3, i4, i5, i6 );
 \end{cfa}
 \begin{lstlisting}[numbers=left]
 …
 For example:
 \begin{cfa}[numbers=left]
+int * i = alloc( ®5`fill® );  sout | i | *i;
+i = alloc( ®i`resize®, ®256`align®, ®7`fill® );  sout | i | *i;
+double * d = alloc( ®i`resize®, ®4096`align®, ®13.5`fill® );  sout | d | *d;
+int * ip = alloc( ®5`fill® );  sout | ip | *ip;
+ip = alloc( ®ip`resize®, ®256`align®, ®7`fill® );  sout | ip | *ip;
+double * dp = alloc( ®ip`resize®, ®4096`align®, ®13.5`fill® );  sout | dp | *dp;
+free( dp );  // DO NOT FREE ip AS ITS STORAGE IS MOVED TO dp
 \end{cfa}
 \begin{lstlisting}[numbers=left]
 x55555556d5c0 5
 x555555570000 7
 x555555571000 13.5
+x555555580a80 5
+x555555581100 7
+x555555587000 13.5
 \end{lstlisting}
 Examples 2 to 3 change the alignment, fill, and size for the initial storage of ©i©.
 \begin{cfa}[numbers=left]
+int * ia = alloc( 5, ®5`fill® );  for ( i; 5 ) sout | ia[i] | nonl; sout | nl;
+ia = alloc( 10, ®ia`resize®, ®7`fill® ); for ( i; 10 ) sout | ia[i] | nonl; sout | nl;
+sout | ia; ia = alloc( 5, ®ia`resize®, ®512`align®, ®13`fill® ); sout | ia; for ( i; 5 ) sout | ia[i] | nonl; sout | nl;;
+ia = alloc( 3, ®ia`resize®, ®4096`align®, ®2`fill® );  sout | ia; for ( i; 3 ) sout | &ia[i] | ia[i] | nonl; sout | nl;
+int * ia = alloc( 5, ®5`fill® );  sout | ia | nonl;  for ( i; 5 ) sout | ia[i] | nonl; sout | nl;
+ia = alloc( 10, ®ia`resize®, ®7`fill® );  sout | ia | nonl;  for ( i; 10 ) sout | ia[i] | nonl; sout | nl;
+ia = alloc( 5, ®ia`resize®, ®512`align®, ®13`fill® ); sout | ia | nonl; for ( i; 5 ) sout | ia[i] | nonl; sout | nl;;
+ia = alloc( 3, ®ia`resize®, ®4096`align®, ®2`fill® );  for ( i; 3 ) sout | &ia[i] | ia[i] | nonl; sout | nl;
+free( ia );
 \end{cfa}
 \begin{lstlisting}[numbers=left]
 5 5 5 5
 7 7 7 7 7 7 7 7 7
 x55555556d560 0x555555571a00 13 13 13 13 13
 x555555572000 0x555555572000 2 0x555555572004 2 0x555555572008 2
+x55555656d540 5 5 5 5 5
+x55555656d480 7 7 7 7 7 7 7 7 7 7
+x55555656fe00 13 13 13 13 13
+x555556570000 2 0x555556570004 2 0x555556570008 2
 \end{lstlisting}
 Examples 2 to 4 change the array size, alignment and fill for the initial storage of ©ia©.
+Examples 2 to 4 change the array size, alignment, and fill initializes all storage because no data is copied.
 \item
 …
 For example:
 \begin{cfa}[numbers=left]
+int * i = alloc( ®5`fill® );  sout | i | *i;
+i = alloc( ®i`realloc®, ®256`align® );  sout | i | *i;
+i = alloc( ®i`realloc®, ®4096`align®, ®13`fill® );  sout | i | *i;
+int * ip = alloc( ®5`fill® );  sout | ip | *ip;
+ip = alloc( ®ip`realloc®, ®256`align® );  sout | ip | *ip;
+ip = alloc( ®ip`realloc®, ®4096`align®, ®13`fill® );  sout | ip | *ip;
+free( ip );
 \end{cfa}
 \begin{lstlisting}[numbers=left]
 …
 \end{lstlisting}
 Examples 2 to 3 change the alignment for the initial storage of ©i©.
 The ©13`fill© in example 3 does nothing because no extra space is added.
+The ©13`fill© in example 3 does nothing because no new storage is added.
 \begin{cfa}[numbers=left]
+int * ia = alloc( 5, ®5`fill® );  for ( i; 5 ) sout | ia[i]; sout | nl;
+ia = alloc( 10, ®ia`realloc®, ®7`fill® ); for ( i; 10 ) sout | ia[i]; sout | nl;
+sout | ia; ia = alloc( 1, ®ia`realloc®, ®512`align®, ®13`fill® ); sout | ia; for ( i; 1 ) sout | ia[i]; sout | nl;;
+ia = alloc( 3, ®ia`realloc®, ®4096`align®, ®2`fill® );  sout | ia; for ( i; 3 ) sout | &ia[i] | ia[i]; sout | nl;
+int * ia = alloc( 5, ®5`fill® );  sout | ia | nonl;  for ( i; 5 ) sout | ia[i] | nonl; sout | nl;
+ia = alloc( 10, ®ia`realloc®, ®7`fill® );  sout | ia | nonl;  for ( i; 10 ) sout | ia[i] | nonl; sout | nl;
+ia = alloc( 5, ®ia`realloc®, ®512`align®, ®13`fill® );  sout | ia | nonl; for ( i; 5 ) sout | ia[i] | nonl; sout | nl;;
+ia = alloc( 3, ®ia`realloc®, ®4096`align®, ®2`fill® );  for ( i; 3 ) sout | &ia[i] | ia[i] | nonl; sout | nl;
+free( ia );
 \end{cfa}
 \begin{lstlisting}[numbers=left]
 5 5 5 5
 5 5 5 5 7 7 7 7 7
 x55555556c560 0x555555570a00 5
 x555555571000 0x555555571000 5 0x555555571004 2 0x555555571008 2
+x55555656d540 5 5 5 5 5
+x55555656d480 7 7 7 7 7 7 7 7 7 7
+x555556570e00 5 5 5 5 5
+x5555556571000 5 0x555556571004 5 0x555556571008 5
 \end{lstlisting}
+Examples 2 to 4 change the array size, alignment and fill for the initial storage of ©ia©.
+The ©13`fill© in example 3 does nothing because no extra space is added.
+Examples 2 to 4 change the array size, alignment, and fill does no initialization after the copied data, as no new storage is added.
 \end{itemize}
 …
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 extern "C" {
         // New allocation operations.
+        // New C allocation operations.
         void * aalloc( size_t dim, size_t elemSize );§\indexc{aalloc}§
         void * resize( void * oaddr, size_t size );§\indexc{resize}§
 …
         size_t malloc_size( void * addr );§\indexc{malloc_size}§
         int malloc_stats_fd( int fd );§\indexc{malloc_stats_fd}§
         size_t malloc_expansion();§\indexc{malloc_expansion}§ $\C{// heap expansion size (bytes)}$
         size_t malloc_mmap_start();§\indexc{malloc_mmap_start}§ $\C{// crossover allocation size from sbrk to mmap}$
         size_t malloc_unfreed();§\indexc{malloc_unfreed()}§     $\C{// heap unfreed size (bytes)}$
         void malloc_stats_clear();§\indexc{malloc_stats_clear}§ $\C{// clear heap statistics}$
+        size_t malloc_expansion();§\indexc{malloc_expansion}§ §\C{// heap expansion size (bytes)}§
+        size_t malloc_mmap_start();§\indexc{malloc_mmap_start}§ §\C{// crossover allocation size from sbrk to mmap}§
+        size_t malloc_unfreed();§\indexc{malloc_unfreed()}§     §\C{// heap unfreed size (bytes)}§
+        void malloc_stats_clear();§\indexc{malloc_stats_clear}§ §\C{// clear heap statistics}§
+}
 …
         T * calloc( size_t dim );§\indexc{calloc}§
         T * resize( T * ptr, size_t size );§\indexc{resize}§
+        T * resize( T * ptr, size_t alignment, size_t size );
         T * realloc( T * ptr, size_t size );§\indexc{realloc}§
+        T * realloc( T * ptr, size_t alignment, size_t size );
         T * reallocarray( T * ptr, size_t dim );§\indexc{reallocarray}§
+        T * reallocarray( T * ptr, size_t alignment, size_t dim );
         T * memalign( size_t align );§\indexc{memalign}§
         T * amemalign( size_t align, size_t dim );§\indexc{amemalign}§
 …
         T * alloc( size_t dim, ... );
         T_align ?`align( size_t alignment );§\indexc{align}§
+        S_fill(T) ?`fill( /* various types */ );§\indexc{fill}§
+        S_resize(T) ?`resize( void * oaddr );§\indexc{resize}§
+        S_realloc(T) ?`realloc( T * a ));§\indexc{realloc}§
+        // §\CFA§ safe initialization/copy, i.e., implicit size specification
+        T * memset( T * dest, char fill );§\indexc{memset}§
+        T * memcpy( T * dest, const T * src );§\indexc{memcpy}§
+        // §\CFA§ safe initialization/copy, i.e., implicit size specification, array types
+        T * amemset( T dest[], char fill, size_t dim );
+        T_fill(T) ?`fill( /* various types */ );§\indexc{fill}§
+        T_resize ?`resize( void * oaddr );§\indexc{resize}§
+        T_realloc ?`realloc( void * oaddr ));§\indexc{realloc}§
+}
+forall( T &, List ... ) void free( T * ptr, ... ) // deallocation list
+// §\CFA§ allocation/deallocation and constructor/destructor, non-array types
+forall( T &, Parms ... | { void ?{}( T &, Parms ); } ) T * new( Parms ... );§\indexc{new}§
+forall( T &, List ... | { void ^?{}( T & ); void delete( List ... ); } );§\indexc{delete}§
+// §\CFA§ allocation/deallocation and constructor/destructor, array types
+forall( T & | sized(T), Parms ... | { void ?{}( T &, Parms ); } ) T * anew( size_t dim, Parms ... );§\indexc{anew}§
+forall( T & | sized(T) | { void ^?{}( T & ); }, List ... } ) void adelete( T arr[], List ... );§\indexc{adelete}§
+\end{cfa}
+\subsection{Memory Set and Copy}
+Like safe memory allocation, \CFA provides safe block initialization and copy.
+While objects should be initialized/copied with constructors/assignment, block operations can be very performant.
+In certain cases the compiler generates block copy operations, such as assigning structures ©s = t©, however C arrays cannot be assigned.
+\begin{cquote}
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+struct S { int i, j, k; };
+S s, t, *sp = &s, * tp = &t, sa[10], ta[10];
+\end{cfa}
+\noindent
+\begin{tabular}{@{}l|l@{}}
+\multicolumn{1}{@{}c|}{\textbf{\CFA}} & \multicolumn{1}{c@{}}{\textbf{C}} \\
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+memset( s, '\0' );
+memset( sp, '\0' );
+memcpy( s, t );
+memcpy( sp, tp );
+amemset( sa, '\0', 10 );
+amemcpy( sa, ta, 10 );
+\end{cfa}
+&
+\begin{cfa}[aboveskip=0pt,belowskip=0pt]
+memset( &s, '\0', sizeof(s) );
+memset( sp, '\0', sizeof(s) );
+memcpy( &s, &t, sizeof(s) );
+memcpy( sp, tp, sizeof(s) );
+memset( sa, '\0', sizeof(sa) );
+memcpy( sa, ta, sizeof(sa) );
+\end{cfa}
+\end{tabular}
+\end{cquote}
+These operations provide uniformity between reference and pointer, so object dereferencing, '©&©', is unnecessary.
+\begin{cfa}
+static inline forall( T & | sized(T) ) {
+        // CFA safe initialization/copy, i.e., implicit size specification, non-array types
+        T * memset( T * dest, char fill );§\indexc{memset}§     §\C{// all combinations of pointer/reference}§
+        T * memset( T & dest, char fill );
+        T * memcpy( T * dest, const T * src );§\indexc{memcpy}§ §\C{// all combinations of pointer/reference}§
+        T * memcpy( T & dest, const T & src );
+        T * memcpy( T * dest, const T & src );
+        T * memcpy( T & dest, const T * src );
+        // CFA safe initialization/copy, i.e., implicit size specification, array types
+        T * amemset( T dest[], char fill, size_t dim );§\indexc{memcpy}§
         T * amemcpy( T dest[], const T src[], size_t dim );
+}
-// §\CFA§ allocation/deallocation and constructor/destructor, non-array types
-forall( T &, TT ... ) void free( T * ptr, ... );
-forall( T & | sized(T), Params ... | { void ?{}( T &, Params ); } )
-T * new( Params p );§\indexc{new}§
-forall( T & | { void ^?{}( T & ); } )
-void delete( T * ptr );§\indexc{delete}§
-forall( T &, Params ... | { void ^?{}( T & ); void delete( Params ); } )
-void delete( T * ptr, Params rest );
-// §\CFA§ allocation/deallocation and constructor/destructor, array types
-forall( T & | sized(T), Params ... | { void ?{}( T &, Params ); } )
-T * anew( size_t dim, Params p );§\indexc{anew}§
-forall( T & | sized(T) | { void ^?{}( T & ); } )
-void adelete( T arr[] );§\indexc{adelete}§
-forall( T & | sized(T) | { void ^?{}( T & ); }, Params ... | { void adelete( Params ); } )
-void adelete( T arr[], Params rest );
 \end{cfa}

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset bab42de

Legend:

doc/user/user.tex

Download in other formats: