Index: libcfa/src/stdlib.hfa
===================================================================
--- libcfa/src/stdlib.hfa	(revision 7df201c0b59cdac5984c3f92d08ff33e03e37c7d)
+++ 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
