Index: doc/user/user.tex
===================================================================
--- doc/user/user.tex	(revision b1d4d60673c9dd9e77c6f8819e10e2a9d7d321a0)
+++ doc/user/user.tex	(revision 49c977357660cc1dd2b3d7775733ba7cdc52aa4c)
@@ -11,6 +11,6 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Tue May 30 11:45:46 2017
-%% Update Count     : 2098
+%% Last Modified On : Thu Jun  1 22:46:09 2017
+%% Update Count     : 2126
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -5242,77 +5242,86 @@
 \begin{description}
 \item[fill]
-after allocation the storage is or is not filled with a specified character.
+after allocation the storage is filled with a specified character.
 \item[resize]
 an existing allocation is decreased or increased in size.
 In either case, new storage may or may not be allocated and, if there is a new allocation, as much data from the existing allocation is copied.
-For an increase in storage size, new storage after the copied data may or may not be filled.
+For an increase in storage size, new storage after the copied data may be filled.
 \item[alignment]
 an allocation starts on a specified memory boundary, e.g., an address multiple of 64 or 128 for cache-line purposes.
 \item[array]
 the allocation size is scaled to the specified number of array elements.
-An array may or not be filled, resized, or aligned.
+An array may be filled, resized, or aligned.
 \end{description}
-
-The following table show the allocation routines supporting different combinations of storage-management capabilities:
+The table shows allocation routines supporting different combinations of storage-management capabilities:
 \begin{center}
-\begin{tabular}{@{}r|l|l|l|l@{}}
-					& fill				& resize	& alignment	& array	\\
+\begin{tabular}{@{}lr|l|l|l|l@{}}
+		&					& \multicolumn{1}{c|}{fill}	& resize	& alignment	& array	\\
 \hline
-©malloc©			& no/yes			& no/yes	& no		& no	\\
-©amalloc©			& no/copy data/yes	& no/yes	& no		& yes	\\
-©calloc©			& yes (0 only)		& no		& no		& yes	\\
-©realloc©			& no/copy data		& yes		& no		& no	\\
-©memalign©			& no/yes			& no		& yes		& no	\\
-©amemalign©			& no/yes			& no		& yes		& yes	\\
-©align_alloc©		& no				& no		& yes		& no	\\
-©posix_memalign©	& no				& no		& yes		& no	\\
+C		& ©malloc©			& no			& no		& no		& no	\\
+		& ©calloc©			& yes (0 only)	& no		& no		& yes	\\
+		& ©realloc©			& no/copy		& yes		& no		& no	\\
+		& ©memalign©		& no			& no		& yes		& no	\\
+		& ©posix_memalign©	& no			& no		& yes		& no	\\
+C11		& ©aligned_alloc©	& no			& no		& yes		& no	\\
+\CFA	& ©alloc©			& no/copy/yes	& no/yes	& no		& yes	\\
+		& ©align_alloc©		& no/yes		& no		& yes		& yes	\\
 \end{tabular}
 \end{center}
-% When ©amalloc© resizes and fills, the space after the copied data from the source is set to the fill character.
 It is impossible to resize with alignment because the underlying ©realloc© allocates storage if more space is needed, and it does not honour alignment from the original allocation.
 
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-// allocation, non-array types
-forall( dtype T | sized(T) ) T * malloc( void );§\indexc{malloc}§
-forall( dtype T | sized(T) ) T * malloc( char fill );
-
-// allocation, array types
-forall( dtype T | sized(T) ) T * calloc( size_t dim );§\indexc{cmalloc}§
-forall( dtype T | sized(T) ) T * amalloc( size_t dim );§\indexc{amalloc}§  // alternate name for calloc
-forall( dtype T | sized(T) ) T * amalloc( size_t dim, char fill );
-
-// resize, non-array types
-forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );§\indexc{realloc}§
-forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill );
-forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size );  // alternate name for realloc
-forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill );
-
-// resize, array types
-forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim );
-forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill );
-
-// alignment, non-array types
-forall( dtype T | sized(T) ) T * memalign( size_t alignment );§\indexc{memalign}§
-forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill );
-forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment );§\indexc{aligned_alloc}§
-forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment );§\indexc{posix_memalign}§
-
-// alignment, array types
-forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim );§\indexc{amemalign}§
-forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim, char fill );
-
-// data, non-array types
+// C unsafe allocation
+extern "C" { void * mallac( size_t size ); }§\indexc{memset}§
+extern "C" { void * calloc( size_t dim, size_t size ); }§\indexc{calloc}§
+extern "C" { void * realloc( void * ptr, size_t size ); }§\indexc{realloc}§
+extern "C" { void * memalign( size_t align, size_t size ); }§\indexc{memalign}§
+extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); }§\indexc{posix_memalign}§
+
+// §\CFA§ safe equivalents, i.e., implicit size specification
+forall( dtype T | sized(T) ) T * malloc( void );
+forall( dtype T | sized(T) ) T * calloc( size_t dim );
+forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );
+forall( dtype T | sized(T) ) T * memalign( size_t align );
+forall( dtype T | sized(T) ) T * aligned_alloc( size_t align );
+forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align );
+
+// §\CFA§ safe general allocation, fill, resize, array
+forall( dtype T | sized(T) ) T * alloc( void );§\indexc{alloc}§
+forall( dtype T | sized(T) ) T * alloc( char fill );
+forall( dtype T | sized(T) ) T * alloc( size_t dim );
+forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill );
+forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim );
+forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
+
+// §\CFA§ safe general allocation, align, fill, array
+forall( dtype T | sized(T) ) T * align_alloc( size_t align );
+forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill );
+forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim );
+forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill );
+
+// C unsafe initialization/copy
+extern "C" { void * memset( void * dest, int c, size_t size ); }
+extern "C" { void * memcpy( void * dest, const void * src, size_t size ); }
+
+// §\CFA§ safe initialization/copy
 forall( dtype T | sized(T) ) T * memset( T * dest, char c );§\indexc{memset}§
 forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src );§\indexc{memcpy}§
 
-// data, array types
-forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c );§\indexc{amemset}§
-forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim );§\indexc{amemcpy}§
-
-// allocation/deallocation and constructor/destructor
-forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );§\indexc{new}§
+// §\CFA§ safe initialization/copy array
+forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c );
+forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim );
+
+// §\CFA§ allocation/deallocation and constructor/destructor
+forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p );§\indexc{new}§
 forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr );§\indexc{delete}§
-forall( dtype T, ttype Params | { void ^?{}( T * ); void delete(Params); } ) void delete( T * ptr, Params rest );
+forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } )
+  void delete( T * ptr, Params rest );
+
+// §\CFA§ allocation/deallocation and constructor/destructor, array
+forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p );§\indexc{anew}§
+forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] );§\indexc{adelete}§
+forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } )
+  void adelete( size_t dim, T arr[], Params rest );
 \end{cfa}
 
Index: src/Parser/lex.ll
===================================================================
--- src/Parser/lex.ll	(revision b1d4d60673c9dd9e77c6f8819e10e2a9d7d321a0)
+++ src/Parser/lex.ll	(revision 49c977357660cc1dd2b3d7775733ba7cdc52aa4c)
@@ -5,11 +5,11 @@
  * file "LICENCE" distributed with Cforall.
  *
- * lex.l --
+ * lex.ll --
  *
  * Author           : Peter A. Buhr
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Mon May 22 07:46:30 2017
- * Update Count     : 525
+ * Last Modified On : Tue May 30 22:00:48 2017
+ * Update Count     : 527
  */
 
@@ -235,5 +235,5 @@
 long			{ KEYWORD_RETURN(LONG); }
 lvalue			{ KEYWORD_RETURN(LVALUE); }				// CFA
-monitor		{ KEYWORD_RETURN(MONITOR); }			// CFA
+monitor			{ KEYWORD_RETURN(MONITOR); }			// CFA
 mutex			{ KEYWORD_RETURN(MUTEX); }				// CFA
 _Noreturn		{ KEYWORD_RETURN(NORETURN); }			// C11
Index: src/libcfa/stdlib
===================================================================
--- src/libcfa/stdlib	(revision b1d4d60673c9dd9e77c6f8819e10e2a9d7d321a0)
+++ src/libcfa/stdlib	(revision 49c977357660cc1dd2b3d7775733ba7cdc52aa4c)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue May 30 09:07:35 2017
-// Update Count     : 164
+// Last Modified On : Thu Jun  1 22:46:43 2017
+// Update Count     : 216
 //
 
@@ -28,6 +28,4 @@
 //---------------------------------------
 
-extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
-
 // allocation, non-array types
 static inline forall( dtype T | sized(T) ) T * malloc( void ) {
@@ -35,83 +33,83 @@
 	return (T *)(void *)malloc( (size_t)sizeof(T) );	// C malloc
 } // malloc
-static inline forall( dtype T | sized(T) ) T * malloc( char fill ) {
+
+extern "C" { void * calloc( size_t dim, size_t size ); } // default C routine
+static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) {
 	//printf( "X2\n" );
+	return (T *)(void *)calloc( dim, sizeof(T) );		// C cmalloc
+}
+
+extern "C" { void * realloc( void * ptr, size_t size ); } // default C routine for void *
+static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) {
+	//printf( "X3\n" );
+	return (T *)(void *)realloc( (void *)ptr, size );
+}
+
+extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void *
+static inline forall( dtype T | sized(T) ) T * memalign( size_t align ) {
+	//printf( "X4\n" );
+	return (T *)memalign( align, sizeof(T) );
+} // memalign
+
+static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t align ) {
+	//printf( "X5\n" );
+	return (T *)memalign( align, sizeof(T) );
+} // aligned_alloc
+
+extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); } // use default C routine for void *
+static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align ) {
+	//printf( "X6\n" );
+	return posix_memalign( (void **)ptr, align, sizeof(T) );
+} // posix_memalign
+
+
+extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
+
+static inline forall( dtype T | sized(T) ) T * alloc( void ) {
+	//printf( "X7\n" );
+	return (T *)(void *)malloc( (size_t)sizeof(T) );	// C malloc
+} // alloc
+static inline forall( dtype T | sized(T) ) T * alloc( char fill ) {
+	//printf( "X8\n" );
 	T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );	// C malloc
     return memset( ptr, (int)fill, sizeof(T) );			// initial with fill value
-} // malloc
-
-// allocation, array types
-extern "C" { void * calloc( size_t dim, size_t size ); } // use default C routine for void *
-static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) {
-	//printf( "X3\n" );
-	return (T *)(void *)calloc( dim, sizeof(T) );		// C cmalloc
-}
-static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim ) { // alternative name
-	//printf( "X4\n" );
+} // alloc
+
+static inline forall( dtype T | sized(T) ) T * alloc( size_t dim ) {
+	//printf( "X9\n" );
 	return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
-} // amalloc
-static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim, char fill ) { // alternative name
-	//printf( "X5\n" );
+} // alloc
+static inline forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill ) {
+	//printf( "X10\n" );
 	T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
     return memset( ptr, (int)fill, dim * sizeof(T) );
-} // amalloc
-
-// resize, non-array types
-extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void *
-static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) {
-	//printf( "X5.5\n" );
-	return (T *)(void *)realloc( (void *)ptr, size );
-}
-forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill );
-static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) {	// alternative name
-	//printf( "X7\n" );
-	return realloc( ptr, size );
-} // malloc
-static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill ) { // alternative name
-	//printf( "X8\n" );
-	return realloc( ptr, size, fill );
-} // malloc
-
-// resize, array types
-static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim ) {
-	//printf( "X9\n" );
-	return malloc( ptr, dim * (size_t)sizeof(T) );
-} // amalloc
-static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill ) {
-	//printf( "X10\n" );
-	return malloc( ptr, dim * (size_t)sizeof(T), fill );
-} // amalloc
-
-// alignment, non-array types
-extern "C" { void * memalign( size_t alignment, size_t size ); } // use default C routine for void *
-static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment ) {
+} // alloc
+
+static inline forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ) {
 	//printf( "X11\n" );
-	return (T *)memalign( alignment, sizeof(T) );
-} // memalign
-static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill ) {
-	//printf( "X12\n" );
-    T * ptr = (T *)memalign( alignment, sizeof(T) );
+	return (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
+} // alloc
+forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
+
+static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align ) {
+	//printf( "X13\n" );
+	return (T *)memalign( align, sizeof(T) );
+} // align_alloc
+static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ) {
+	//printf( "X14\n" );
+    T * ptr = (T *)memalign( align, sizeof(T) );
     return memset( ptr, (int)fill, sizeof(T) );
-} // memalign
-static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) {
-	//printf( "X13\n" );
-	return (T *)memalign( alignment, sizeof(T) );
-} // aligned_alloc
-extern "C" { int posix_memalign( void ** ptr, size_t alignment, size_t size ); } // use default C routine for void *
-static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) {
-	//printf( "X14\n" );
-	return posix_memalign( (void **)ptr, alignment, sizeof(T) );
-} // posix_memalign
-
-// alignment, array types
-static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim ) {
+} // align_alloc
+
+static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ) {
 	//printf( "X15\n" );
-	return (T *)memalign( alignment, dim * sizeof(T) );
-} // amemalign
-static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim, char fill ) {
+	return (T *)memalign( align, dim * sizeof(T) );
+} // align_alloc
+static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ) {
 	//printf( "X16\n" );
-    T * ptr = (T *)memalign( alignment, dim * sizeof(T) );
+    T * ptr = (T *)memalign( align, dim * sizeof(T) );
     return memset( ptr, (int)fill, dim * sizeof(T) );
-} // amemalign
+} // align_alloc
+
 
 // data, non-array types
@@ -127,17 +125,22 @@
 
 // data, array types
-static inline forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c ) {
+static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) {
 	//printf( "X19\n" );
 	return memset( dest, c, dim * sizeof(T) );
-} // amemset
-static inline forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim ) {
+} // memset
+static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) {
 	//printf( "X20\n" );
-	return memcpy( dest, src, dim * sizeof(T) );
-} // amemcpy
-
-// allocation/deallocation and constructor/destructor
-forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );
+	return (void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
+} // memcpy
+
+// allocation/deallocation and constructor/destructor, non-array types
+forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p );
 forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr );
 forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest );
+
+// allocation/deallocation and constructor/destructor, array types
+forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p );
+forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] );
+forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest );
 
 //---------------------------------------
Index: src/libcfa/stdlib.c
===================================================================
--- src/libcfa/stdlib.c	(revision b1d4d60673c9dd9e77c6f8819e10e2a9d7d321a0)
+++ src/libcfa/stdlib.c	(revision 49c977357660cc1dd2b3d7775733ba7cdc52aa4c)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue May 30 09:07:56 2017
-// Update Count     : 237
+// Last Modified On : Thu Jun  1 21:52:57 2017
+// Update Count     : 280
 //
 
@@ -28,8 +28,7 @@
 
 // resize, non-array types
-forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ) { // alternative realloc with fill value
-	//printf( "X6\n" );
+forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ) {
 	size_t olen = malloc_usable_size( ptr );			// current allocation
-    char * nptr = (void *)realloc( (void *)ptr, size );	// C realloc
+    char * nptr = (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
 	size_t nlen = malloc_usable_size( nptr );			// new allocation
 	if ( nlen > olen ) {								// larger ?
@@ -37,15 +36,15 @@
 	} // 
     return (T *)nptr;
-} // realloc
-
-// allocation/deallocation and constructor/destructor
-forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } )
+} // alloc
+
+// allocation/deallocation and constructor/destructor, non-array types
+forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } )
 T * new( Params p ) {
-	return ((T *)malloc()){ p };
+	return (malloc()){ p };								// run constructor
 } // new
 
 forall( dtype T | { void ^?{}( T * ); } )
 void delete( T * ptr ) {
-	if ( ptr ) {
+	if ( ptr ) {										// ignore null
 		^ptr{};											// run destructor
 		free( ptr );
@@ -55,5 +54,5 @@
 forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } )
 void delete( T * ptr, Params rest ) {
-	if ( ptr ) {
+	if ( ptr ) {										// ignore null
 		^ptr{};											// run destructor
 		free( ptr );
@@ -61,4 +60,36 @@
 	delete( rest );
 } // delete
+
+
+// allocation/deallocation and constructor/destructor, array types
+forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } )
+T * anew( size_t dim, Params p ) {
+	T *arr = alloc( dim );
+	for ( unsigned int i = 0; i < dim; i += 1 ) {
+		(&arr[i]){ p };									// run constructor
+	} // for
+	return arr;
+} // anew
+
+forall( dtype T | sized(T) | { void ^?{}( T * ); } )
+void adelete( size_t dim, T arr[] ) {
+	if ( arr ) {										// ignore null
+		for ( int i = dim - 1; i >= 0; i -= 1 ) {		// reverse allocation order, must be unsigned
+			^(&arr[i]){};								// run destructor
+		} // for
+		free( arr );
+	} // if
+} // adelete
+
+forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } )
+void adelete( size_t dim, T arr[], Params rest ) {
+	if ( arr ) {										// ignore null
+		for ( int i = dim - 1; i >= 0; i -= 1 ) {		// reverse allocation order, must be unsigned
+			^(&arr[i]){};								// run destructor
+		} // for
+		free( arr );
+	} // if
+	adelete( rest );
+} // adelete
 
 //---------------------------------------
Index: src/tests/.expect/alloc.txt
===================================================================
--- src/tests/.expect/alloc.txt	(revision b1d4d60673c9dd9e77c6f8819e10e2a9d7d321a0)
+++ src/tests/.expect/alloc.txt	(revision 49c977357660cc1dd2b3d7775733ba7cdc52aa4c)
@@ -1,56 +1,63 @@
-C   malloc deadbeef
-CFA malloc 0
-CFA malloc, fill 01010101
+C   malloc 0xdeadbeef
+CFA malloc 0xdeadbeef
+CFA alloc 0xdeadbeef
+CFA alloc, fill 01010101
 
-C   calloc
+C   array calloc, fill 0
 0 0 0 0 0 0 0 0 0 0 
-CFA calloc
+CFA array calloc, fill 0
 0 0 0 0 0 0 0 0 0 0 
-CFA array malloc
-0 0 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 
-CFA array malloc
-1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 
+CFA array alloc, no fill
+0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 
+CFA array alloc, fill 0x1
+0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 
 
-C   realloc
-deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 
-CFA realloc
-deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0 
-CFA realloc
-deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 
-CFA resize malloc
-deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 
-CFA resize malloc, fill
-deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 
-CFA resize malloc, fill
-deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 
+C   realloc 40
+0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 
+CFA realloc 88
+0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 
 
-CFA resize array malloc
-deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0 
-CFA resize array malloc
-deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 
-CFA resize array malloc, fill
-deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 
-CFA resize array malloc, fill
-deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 
+CFA resize alloc 40
+0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 
+CFA resize array alloc 88
+0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 
+CFA resize array alloc 40
+0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 
+CFA resize array alloc 40, fill
+0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 
+CFA resize array alloc 88, fill
+0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 
+CFA resize array alloc 40, fill
+0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 
 
-CFA aligned_alloc 42 42.5
+C   memalign 42 42.5
 CFA memalign 42 42.5
 CFA posix_memalign 42 42.5
-CFA memalign fill 16843009 7.7486e-304
+CFA posix_memalign 42 42.5
+CFA aligned_alloc 42 42.5
+CFA align_alloc 42 42.5
+CFA align_alloc fill 0x1010101 0x1.1010101010101p-1007
 
-CFA memalign array
-0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 
-CFA memalign array
-1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 
+CFA array align_alloc
+42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 
+CFA array align_alloc, fill
+0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 
 
-CFA memset ffffffff -nan
-CFA memcpy ffffffff -nan
+CFA memset 0x1010101 0x1.1010101010101p-1007
+CFA memcpy 0x1010101 0x1.1010101010101p-1007
 
 CFA array memset
-ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, 
+0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 
 CFA memcpy
-deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, 
+0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 
+
+CFA new initialize
+42 42.5 42 42.5
+CFA array new initialize
+42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 
+42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 
+
 pointer arithmetic 0
-CFA deep malloc deadbeef
+CFA deep malloc 0xdeadbeef
 
 SHOULD FAIL
Index: src/tests/alloc.c
===================================================================
--- src/tests/alloc.c	(revision b1d4d60673c9dd9e77c6f8819e10e2a9d7d321a0)
+++ src/tests/alloc.c	(revision 49c977357660cc1dd2b3d7775733ba7cdc52aa4c)
@@ -10,6 +10,6 @@
 // Created On       : Wed Feb  3 07:56:22 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 29 11:33:15 2017
-// Update Count     : 228
+// Last Modified On : Thu Jun  1 21:33:49 2017
+// Update Count     : 315
 // 
 
@@ -18,4 +18,5 @@
 #include <malloc.h>										// malloc_usable_size
 #include <stdint.h>										// uintptr_t
+#include <stdlib.h>										// posix_memalign
 } // extern
 #include <fstream>
@@ -28,6 +29,6 @@
 int main( void ) {
     size_t dim = 10;
-    struct S { int x; double y; } * s;
     int * p;
+	char fill = '\1';
 
 	// allocation, non-array types
@@ -35,13 +36,19 @@
     p = (void *)malloc( sizeof(*p) );					// C malloc, type unsafe
 	*p = 0xdeadbeef;
-	printf( "C   malloc %x\n", *p );
+	printf( "C   malloc %#x\n", *p );
     free( p );
 
     p = malloc();										// CFA malloc, type safe
-	printf( "CFA malloc %d\n", *p );
-    free( p );
-
-    p = malloc( '\1' );									// CFA malloc, fill
-	printf( "CFA malloc, fill %08x\n", *p );
+	*p = 0xdeadbeef;
+	printf( "CFA malloc %#x\n", *p );
+    free( p );
+
+    p = alloc();										// CFA alloc, type safe
+	*p = 0xdeadbeef;
+	printf( "CFA alloc %#x\n", *p );
+    free( p );
+
+    p = alloc( fill );									// CFA alloc, fill
+	printf( "CFA alloc, fill %08x\n", *p );
 
 
@@ -50,24 +57,25 @@
 
     p = calloc( dim, sizeof( *p ) );					// C array calloc, type unsafe
-	printf( "C   calloc\n" );
-	for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
+	printf( "C   array calloc, fill 0\n" );
+	for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
 	printf( "\n" );
     free( p );
 
     p = calloc( dim );									// CFA array calloc, type safe
-	printf( "CFA calloc\n" );
-	for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
-	printf( "\n" );
-    free( p );
-
-    p = amalloc( dim );									// CFA array malloc, type safe
-	printf( "CFA array malloc\n" );
-	for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
-	printf( "\n" );
-    free( p );
-
-    p = amalloc( 2 * dim, '\1' );						// CFA array malloc, fill
-	printf( "CFA array malloc\n" );
-	for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
+	printf( "CFA array calloc, fill 0\n" );
+	for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
+	printf( "\n" );
+    free( p );
+
+    p = alloc( dim );									// CFA array alloc, type safe
+	for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
+	printf( "CFA array alloc, no fill\n" );
+	for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
+	printf( "\n" );
+    free( p );
+
+    p = alloc( 2 * dim, fill );							// CFA array alloc, fill
+	printf( "CFA array alloc, fill %#x\n", fill );
+	for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
 	printf( "\n" );
 	// do not free
@@ -77,32 +85,14 @@
 	printf( "\n" );
 
-    p = (void *)realloc( p, dim * sizeof(*p) );			// CFA realloc
-	printf( "C   realloc\n" );
-	for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
+    p = (void *)realloc( p, dim * sizeof(*p) );			// C realloc
+	for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
+	printf( "C   realloc %ld\n", malloc_usable_size( p ) );
+	for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
 	printf( "\n" );
 
     p = realloc( p, 2 * dim * sizeof(*p) );				// CFA realloc
-	printf( "CFA realloc\n" );
-	for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
-	printf( "\n" );
-
-    p = realloc( p, dim * sizeof(*p), '\1' );			// CFA realloc
-	printf( "CFA realloc\n" );
-	for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
-	printf( "\n" );
-
-    p = malloc( p, dim * sizeof(*p) );					// CFA malloc
-	printf( "CFA resize malloc\n" );
-	for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
-	printf( "\n" );
-
-    p = malloc( p, 2 * dim * sizeof(*p), '\1' );		// CFA malloc, fill
-	printf( "CFA resize malloc, fill\n" );
-	for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
-	printf( "\n" );
-
-    p = malloc( p, dim * sizeof(*p), '\1' );			// CFA malloc, fill
-	printf( "CFA resize malloc, fill\n" );
-	for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
+	for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
+	printf( "CFA realloc %ld\n", malloc_usable_size( p ) );
+	for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
 	printf( "\n" );
 	// do not free
@@ -112,43 +102,62 @@
 	printf( "\n" );
 
-    p = amalloc( p, 2 * dim );							// CFA array malloc
-	printf( "CFA resize array malloc\n" );
-	for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
-	printf( "\n" );
-
-    p = amalloc( p, dim );								// CFA array malloc
-	printf( "CFA resize array malloc\n" );
-	for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
-	printf( "\n" );
-
-    p = amalloc( p, 2 * dim, '\1' );					// CFA array malloc, fill
-	printf( "CFA resize array malloc, fill\n" );
-	for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
-	printf( "\n" );
-
-    p = amalloc( p, dim, '\1' );						// CFA array malloc, fill
-	printf( "CFA resize array malloc, fill\n" );
-	for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
+    p = alloc( p, dim );								// CFA resize array alloc
+	for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
+	printf( "CFA resize alloc %ld\n", malloc_usable_size( p ) );
+	for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
+	printf( "\n" );
+
+    p = alloc( p, 2 * dim );							// CFA resize array alloc
+	for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
+	printf( "CFA resize array alloc %ld\n", malloc_usable_size( p ) );
+	for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
+	printf( "\n" );
+
+    p = alloc( p, dim );								// CFA array alloc
+	printf( "CFA resize array alloc %ld\n", malloc_usable_size( p ) );
+	for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
+	printf( "\n" );
+
 	free( p );
-	printf( "\n" );
+	p = 0;
+
+    p = alloc( p, dim, fill );							// CFA array alloc, fill
+	printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) );
+	for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
+	printf( "\n" );
+
+    p = alloc( p, 2 * dim, fill );						// CFA array alloc, fill
+	printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) );
+	for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
+	printf( "\n" );
+
+    p = alloc( p, dim, fill );							// CFA array alloc, fill
+	printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) );
+	for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; }
+	printf( "\n" );
+	free( p );
+
 
     struct Struct { int x; double y; };
-    Struct st, st1, sta[dim], sta1[dim], * stp;
-
+    Struct st, st1, sta[dim], sta1[dim], * stp, * stp1;
 
 	// alignment, non-array types
 	printf( "\n" );
-
 	enum { Alignment = 128 };
-    stp = aligned_alloc( Alignment );					// CFA aligned_alloc
+
+    stp = (memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign
+	assert( (uintptr_t)stp % Alignment == 0 );
+	printf( "C   memalign %d %g\n", stp->x, stp->y );
+    free( stp );
+
+    stp = (memalign( Alignment )){ 42, 42.5 };			// CFA memalign
+	assert( (uintptr_t)stp % Alignment == 0 );
+	printf( "CFA memalign %d %g\n", stp->x, stp->y );
+    free( stp );
+
+    posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) );	// C posix_memalign
 	*stp = (Struct){ 42, 42.5 };
 	assert( (uintptr_t)stp % Alignment == 0 );
-	printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y );
-    free( stp );
-
-    stp = memalign( Alignment );						// CFA memalign
-	*stp = (Struct){ 42, 42.5 };
-	assert( (uintptr_t)stp % Alignment == 0 );
-	printf( "CFA memalign %d %g\n", stp->x, stp->y );
+	printf( "CFA posix_memalign %d %g\n", stp->x, stp->y );
     free( stp );
 
@@ -159,7 +168,17 @@
     free( stp );
 
-    stp = memalign( Alignment, '\1' );					// CFA memalign, fill
-	assert( (uintptr_t)stp % Alignment == 0 );
-	printf( "CFA memalign fill %d %g\n", stp->x, stp->y );
+    stp = (aligned_alloc( Alignment )){ 42, 42.5 };		// CFA aligned_alloc
+	assert( (uintptr_t)stp % Alignment == 0 );
+	printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y );
+    free( stp );
+
+    stp = (align_alloc( Alignment )){ 42, 42.5 };		// CFA align_alloc
+	assert( (uintptr_t)stp % Alignment == 0 );
+	printf( "CFA align_alloc %d %g\n", stp->x, stp->y );
+    free( stp );
+
+    stp = align_alloc( Alignment, fill );				// CFA memalign, fill
+	assert( (uintptr_t)stp % Alignment == 0 );
+	printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y );
     free( stp );
 
@@ -168,15 +187,16 @@
 	printf( "\n" );
 
-    stp = amemalign( Alignment, 2 * dim );				// CFA array memalign
-	assert( (uintptr_t)stp % Alignment == 0 );
-	printf( "CFA memalign array\n" );
-	for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x %g, ", stp[i].x, stp[i].y ); stp[i].x = 0Xdeadbeef, stp[i].y = -17.2; }
-	printf( "\n" );
-    free( stp );
-
-    stp = amemalign( Alignment, dim, '\1' );			// CFA array memalign, fill
-	assert( (uintptr_t)stp % Alignment == 0 );
-	printf( "CFA memalign array\n" );
-	for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", stp[i].x, stp[i].y ); stp[i].x = 0Xdeadbeef, stp[i].y = -17.2; }
+    stp = align_alloc( Alignment, dim );				// CFA array memalign
+	assert( (uintptr_t)stp % Alignment == 0 );
+	for ( int i = 0; i < dim; i += 1 ) { stp[i] = (Struct){ 42, 42.5 }; }
+	printf( "CFA array align_alloc\n" );
+	for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
+	printf( "\n" );
+    free( stp );
+
+    stp = align_alloc( Alignment, dim, fill );			// CFA array memalign, fill
+	assert( (uintptr_t)stp % Alignment == 0 );
+	printf( "CFA array align_alloc, fill\n" );
+	for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); }
 	printf( "\n" );
     free( stp );
@@ -186,8 +206,8 @@
 	printf( "\n" );
 
-    stp = memset( &st, '\xff' );						// CFA memset, type safe
-	printf( "CFA memset %x %g\n", st.x, st.y );
-    stp = memcpy( &st1, &st );							// CFA memcpy, type safe
-	printf( "CFA memcpy %x %g\n", st1.x, st1.y );
+    memset( &st, fill );								// CFA memset, type safe
+	printf( "CFA memset %#x %a\n", st.x, st.y );
+    memcpy( &st1, &st );								// CFA memcpy, type safe
+	printf( "CFA memcpy %#x %a\n", st1.x, st1.y );
 
 
@@ -195,12 +215,34 @@
 	printf( "\n" );
 
-    stp = amemset( sta, dim, '\xff' );					// CFA array memset, type safe
+    memset( sta, dim, fill );							// CFA array memset, type safe
 	printf( "CFA array memset\n" );
-	for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", sta[i].x, sta[i].y ); sta[i].x = 0Xdeadbeef, sta[i].y = -17.2; }
-	printf( "\n" );
-
-    stp = amemcpy( sta1, sta, dim );					// CFA array memcpy, type safe
+	for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); }
+	printf( "\n" );
+
+    memcpy( sta1, sta, dim );							// CFA array memcpy, type safe
 	printf( "CFA memcpy\n" );
-	for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", sta1[i].x, sta1[i].y ); sta1[i].x = 0Xdeadbeef, sta1[i].y = -17.2; }
+	for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); }
+	printf( "\n" );
+
+
+	// new, non-array types
+	printf( "\n" );
+
+	stp = new( 42, 42.5 );
+	stp1 = new( 42, 42.5 );
+	printf( "CFA new initialize\n%d %g %d %g\n", stp->x, stp->y, stp1->x, stp1->y );
+	delete( stp, stp1 );
+
+	// new, array types
+	stp = anew( dim, 42, 42.5 );
+	printf( "CFA array new initialize\n" );
+	for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
+	printf( "\n" );
+	stp1 = anew( dim, 42, 42.5 );
+	for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
+	printf( "\n" );
+	adelete( dim, stp, dim, stp1 );
+
+	// extras
 	printf( "\n" );
 
@@ -211,10 +253,10 @@
     p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
 	*p = 0xdeadbeef;
-	printf( "CFA deep malloc %x\n", *p );
+	printf( "CFA deep malloc %#x\n", *p );
     free( p );
 
 	stp = malloc();
 	printf( "\nSHOULD FAIL\n" );
-    p = malloc( stp, dim * sizeof(*stp) );
+    p = alloc( stp, dim * sizeof(*stp) );
     p = memset( stp, 10 );
     p = memcpy( &st1, &st );
