Index: doc/user/user.tex =================================================================== --- doc/user/user.tex (revision 89da3a994f3a8944d318eebe5bbac3ced5d87f37) +++ doc/user/user.tex (revision bab42dedcae60fabba662dd711ba8169f2a37e4e) @@ -11,6 +11,6 @@ %% 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 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -69,5 +69,5 @@ \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}} {} @@ -2961,5 +2961,4 @@ 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} @@ -2967,7 +2966,7 @@ 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: @@ -3061,4 +3060,5 @@ \subsection{Postfix Function} \label{s:PostfixFunction} +\index{postfix function} \CFA provides an alternative call syntax where the argument appears before the function name. @@ -3081,5 +3081,5 @@ '1'`m; "123" "456"`m; -[1,2,3]`t; +[1, 2, 3]`t; \end{cfa} & @@ -3100,4 +3100,6 @@ \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. @@ -3124,17 +3126,17 @@ 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} @@ -3149,17 +3151,17 @@ 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++} @@ -3544,4 +3546,5 @@ \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. @@ -4202,6 +4205,5 @@ [ §\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. @@ -4241,9 +4243,8 @@ 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} @@ -8142,4 +8143,5 @@ \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. @@ -8148,4 +8150,5 @@ \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©). @@ -8210,10 +8213,10 @@ \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} @@ -8221,5 +8224,5 @@ \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 @@ -8233,17 +8236,17 @@ \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}§ @@ -8261,4 +8264,8 @@ 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} @@ -8274,11 +8281,15 @@ \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©, @@ -8286,16 +8297,16 @@ \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; - -0x555555572000 -0x555555574000 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 ); + +0x5555565699®00® // 256 alignment +0x55555656c®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} @@ -8309,5 +8320,5 @@ 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; @@ -8316,4 +8327,5 @@ 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] @@ -8334,28 +8346,30 @@ 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] -0x55555556d5c0 5 -0x555555570000 7 -0x555555571000 13.5 +0x555555580a80 5 +0x555555581100 7 +0x555555587000 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 5 -7 7 7 7 7 7 7 7 7 7 -0x55555556d560 0x555555571a00 13 13 13 13 13 -0x555555572000 0x555555572000 2 0x555555572004 2 0x555555572008 2 +0x55555656d540 5 5 5 5 5 +0x55555656d480 7 7 7 7 7 7 7 7 7 7 +0x55555656fe00 13 13 13 13 13 +0x555556570000 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 @@ -8366,7 +8380,8 @@ 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] @@ -8376,20 +8391,20 @@ \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 5 5 7 7 7 7 7 -0x55555556c560 0x555555570a00 5 -0x555555571000 0x555555571000 5 0x555555571004 2 0x555555571008 2 +0x55555656d540 5 5 5 5 5 +0x55555656d480 7 7 7 7 7 7 7 7 7 7 +0x555556570e00 5 5 5 5 5 +0x5555556571000 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} @@ -8397,5 +8412,5 @@ \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}§ @@ -8406,8 +8421,8 @@ 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}§ } @@ -8423,6 +8438,9 @@ 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}§ @@ -8437,34 +8455,73 @@ 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}