Index: libcfa/src/stdlib.cfa
===================================================================
--- libcfa/src/stdlib.cfa	(revision 1aa6ecb22c586c21852eaca5651a1572ff7b12a6)
+++ libcfa/src/stdlib.cfa	(revision cafb687b0747426341d347fa662a88c623c5c314)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jun 24 17:34:44 2019
-// Update Count     : 462
+// Last Modified On : Sun Oct 20 18:41:23 2019
+// Update Count     : 473
 //
 
@@ -27,19 +27,60 @@
 //---------------------------------------
 
-// resize, non-array types
-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, dim * (size_t)sizeof(T) ); // C realloc
-	size_t nlen = malloc_usable_size( nptr );			// new allocation
-	if ( nlen > olen ) {								// larger ?
-		memset( nptr + olen, (int)fill, nlen - olen );	// initialize added storage
-	} //
-    return (T *)nptr;
-} // alloc
+forall( dtype T | sized(T) ) {
+	T * alloc_set( T ptr[], size_t dim, char fill ) {	// realloc array with fill
+		size_t olen = malloc_usable_size( ptr );		// current allocation
+		char * nptr = (char *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
+		size_t nlen = malloc_usable_size( nptr );		// new allocation
+		if ( nlen > olen ) {							// larger ?
+			memset( nptr + olen, (int)fill, nlen - olen ); // initialize added storage
+		} // if
+		return (T *)nptr;
+	} // alloc_set
+
+	T * alloc_align( T ptr[], size_t align ) {			// aligned realloc array
+		char * nptr;
+		size_t alignment = malloc_alignment( ptr );
+		if ( align != alignment ) {
+			size_t olen = malloc_usable_size( ptr );	// current allocation
+			nptr = (char *)memalign( align, olen );
+			size_t nlen = malloc_usable_size( nptr );	// new allocation
+			size_t lnth = olen < nlen ? olen : nlen;	// min
+			memcpy( nptr, ptr, lnth );					// initialize storage
+		} else {
+			nptr = (char *)ptr;
+		} // if
+		return (T *)nptr;
+	} // alloc_align
+
+	T * alloc_align( T ptr[], size_t align, size_t dim ) { // aligned realloc array
+		char * nptr;
+		size_t alignment = malloc_alignment( ptr );
+		if ( align != alignment ) {
+			size_t olen = malloc_usable_size( ptr );	// current allocation
+			nptr = (char *)memalign( align, dim * sizeof(T) );
+			size_t nlen = malloc_usable_size( nptr );	// new allocation
+			size_t lnth = olen < nlen ? olen : nlen;	// min
+			memcpy( nptr, ptr, lnth );					// initialize storage
+		} else {
+			nptr = (char *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
+		} // if
+		return (T *)nptr;
+	} // alloc_align
+
+	T * alloc_align_set( T ptr[], size_t align, char fill ) { // aligned realloc with fill
+		size_t olen = malloc_usable_size( ptr );		// current allocation
+		char * nptr = alloc_align( ptr, align );
+		size_t nlen = malloc_usable_size( nptr );		// new allocation
+		if ( nlen > olen ) {							// larger ?
+			memset( nptr + olen, (int)fill, nlen - olen ); // initialize added storage
+		} // if
+		return (T *)nptr;
+	} // alloc_align_set
+} // distribution
 
 // allocation/deallocation and constructor/destructor, non-array types
 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } )
 T * new( Params p ) {
-	return &(*malloc()){ p };								// run constructor
+	return &(*malloc()){ p };							// run constructor
 } // new
 
@@ -47,5 +88,5 @@
 void delete( T * ptr ) {
 	if ( ptr ) {										// ignore null
-		^(*ptr){};											// run destructor
+		^(*ptr){};										// run destructor
 		free( ptr );
 	} // if
@@ -55,5 +96,5 @@
 void delete( T * ptr, Params rest ) {
 	if ( ptr ) {										// ignore null
-		^(*ptr){};											// run destructor
+		^(*ptr){};										// run destructor
 		free( ptr );
 	} // if
Index: libcfa/src/stdlib.hfa
===================================================================
--- libcfa/src/stdlib.hfa	(revision 1aa6ecb22c586c21852eaca5651a1572ff7b12a6)
+++ libcfa/src/stdlib.hfa	(revision cafb687b0747426341d347fa662a88c623c5c314)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Sep 27 12:09:18 2019
-// Update Count     : 381
+// Last Modified On : Sun Oct 20 22:57:33 2019
+// Update Count     : 390
 //
 
@@ -25,5 +25,5 @@
 	void * memset( void * dest, int fill, size_t size ); // string.h
 	void * memcpy( void * dest, const void * src, size_t size ); // string.h
-    void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA
+    void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA heap
 } // extern "C"
 
@@ -52,13 +52,13 @@
 	T * realloc( T * ptr, size_t size ) {
 		if ( unlikely( ptr == 0 ) ) return malloc();
-		return (T *)(void *)realloc( (void *)ptr, size );
+		return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
 	} // realloc
 
 	T * memalign( size_t align ) {
-		return (T *)memalign( align, sizeof(T) );
+		return (T *)memalign( align, sizeof(T) );		// C memalign
 	} // memalign
 
 	T * aligned_alloc( size_t align ) {
-		return (T *)aligned_alloc( align, sizeof(T) );
+		return (T *)aligned_alloc( align, sizeof(T) );	// C aligned_alloc
 	} // aligned_alloc
 
@@ -67,5 +67,4 @@
 	} // posix_memalign
 
-
 	// Cforall dynamic allocation
 
@@ -74,25 +73,26 @@
 	} // alloc
 
-	T * alloc( char fill ) {
-		T * ptr;
-		if ( _Alignof(T) <= libAlign() ) ptr = (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
-		else ptr = (T *)memalign( _Alignof(T), sizeof(T) );
-		return (T *)memset( ptr, (int)fill, sizeof(T) ); // initialize with fill value
-	} // alloc
-
-	T * alloc( T & fill ) {
+	T * alloc( size_t dim ) {
+		if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( dim * (size_t)sizeof(T) );
+		else return (T *)memalign( _Alignof(T), dim * sizeof(T) );
+	} // alloc
+
+	T * alloc( T ptr[], size_t dim ) {					// realloc
+		return realloc( ptr, dim * sizeof(T) );
+	} // alloc
+
+	T * alloc_set( char fill ) {
+		return (T *)memset( (T *)alloc(), (int)fill, sizeof(T) ); // initialize with fill value
+	} // alloc
+
+	T * alloc_set( T fill ) {
 		return (T *)memcpy( (T *)alloc(), &fill, sizeof(T) ); // initialize with fill value
 	} // alloc
 
-	T * alloc( size_t dim ) {
-		if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
-		else return (T *)memalign( _Alignof(T), dim * sizeof(T) );
-	} // alloc
-
-	T * alloc( size_t dim, char fill ) {
+	T * alloc_set( size_t dim, char fill ) {
 		return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
 	} // alloc
 
-	T * alloc( size_t dim, T & fill ) {
+	T * alloc_set( size_t dim, T fill ) {
 		T * r = (T *)alloc( dim );
 		for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
@@ -100,43 +100,53 @@
 	} // alloc
 
-	T * alloc( size_t dim, T fill[] ) {
+	T * alloc_set( size_t dim, const T fill[] ) {
 		return (T *)memcpy( (T *)alloc( dim ), fill, dim * sizeof(T) ); // initialize with fill value
 	} // alloc
-
-	T * alloc( T ptr[], size_t dim ) {
-		return realloc( ptr, dim * sizeof(T) );
-	} // alloc
-} // distribution
-
-
-static inline forall( dtype T | sized(T) ) {
-	T * align_alloc( size_t align ) {
+} // distribution
+
+forall( dtype T | sized(T) ) {
+	T * alloc_set( T ptr[], size_t dim, char fill );	// realloc array with fill
+} // distribution
+
+static inline forall( dtype T | sized(T) ) {
+	T * alloc_align( size_t align ) {
 		return (T *)memalign( align, sizeof(T) );
-	} // align_alloc
-
-	T * align_alloc( size_t align, char fill ) {
-		T * ptr = (T *)memalign( align, sizeof(T) );
-		return (T *)memset( ptr, (int)fill, sizeof(T) );
-	} // align_alloc
-
-	T * align_alloc( size_t align, size_t dim ) {
+	} // alloc_align
+
+	T * alloc_align( size_t align, size_t dim ) {
 		return (T *)memalign( align, dim * sizeof(T) );
-	} // align_alloc
-
-	T * align_alloc( size_t align, size_t dim, char fill ) {
-		if ( fill == '\0' ) {
-			return (T *)cmemalign( align, dim, sizeof(T) );
-		} else {
-			return (T *)memset( (T *)memalign( align, dim * sizeof(T) ), (int)fill, dim * sizeof(T) );
-		} // if
-	} // align_alloc
-} // distribution
-
-forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
-
+	} // alloc_align
+
+	T * alloc_align_set( size_t align, char fill ) {
+		return (T *)memset( (T *)alloc_align( align ), (int)fill, sizeof(T) ); // initialize with fill value
+	} // alloc_align
+
+	T * alloc_align_set( size_t align, T fill ) {
+		return (T *)memcpy( (T *)alloc_align( align ), &fill, sizeof(T) ); // initialize with fill value
+	} // alloc_align
+
+	T * alloc_align_set( size_t align, size_t dim, char fill ) {
+		return (T *)memset( (T *)alloc_align( align, dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
+	} // alloc_align
+
+	T * alloc_align_set( size_t align, size_t dim, T fill ) {
+		T * r = (T *)alloc_align( align, dim );
+		for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
+		return r;
+	} // alloc_align
+
+	T * alloc_align_set( size_t align, size_t dim, const T fill[] ) {
+		return (T *)memcpy( (T *)alloc_align( align, dim ), fill, dim * sizeof(T) );
+	} // alloc_align
+} // distribution
+
+forall( dtype T | sized(T) ) {
+	T * alloc_align( T ptr[], size_t align );			// realign
+	T * alloc_align( T ptr[], size_t align, size_t dim ); // aligned realloc array
+	T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); // aligned realloc array with fill
+} // distribution
 
 static inline forall( dtype T | sized(T) ) {
 	// data, non-array types
-
 	T * memset( T * dest, char fill ) {
 		return (T *)memset( dest, fill, sizeof(T) );
@@ -150,5 +160,4 @@
 static inline forall( dtype T | sized(T) ) {
 	// data, array types
-
 	T * amemset( T dest[], char fill, size_t dim ) {
 		return (T *)(void *)memset( dest, fill, dim * sizeof(T) ); // C memset