Index: src/libcfa/stdlib
===================================================================
--- src/libcfa/stdlib	(revision 8dc51c8cff43960ff94f70d1a6b0d289417c4c8a)
+++ src/libcfa/stdlib	(revision eb0951d0cd306bfecdc590fa7b0b243eb3ed1853)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed May 24 18:06:27 2017
-// Update Count     : 115
+// Last Modified On : Tue May 30 09:07:35 2017
+// Update Count     : 164
 //
 
@@ -28,21 +28,116 @@
 //---------------------------------------
 
-forall( dtype T | sized(T) ) T * malloc( void );
-forall( dtype T | sized(T) ) T * malloc( char fill );
-forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size );
-forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, unsigned char fill );
-extern "C" { void * calloc( size_t nmemb, size_t size ); } // use default C routine for void *
-forall( dtype T | sized(T) ) T * calloc( size_t nmemb );
+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 ) {
+	//printf( "X1\n" );
+	return (T *)(void *)malloc( (size_t)sizeof(T) );	// C malloc
+} // malloc
+static inline forall( dtype T | sized(T) ) T * malloc( char fill ) {
+	//printf( "X2\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" );
+	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" );
+	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 *
-forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );
-forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, unsigned char fill );
-
-forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment );
-forall( dtype T | sized(T) ) T * memalign( size_t alignment );		// deprecated
-forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment );
-
+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 ) {
+	//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 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 ) {
+	//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 ) {
+	//printf( "X16\n" );
+    T * ptr = (T *)memalign( alignment, dim * sizeof(T) );
+    return memset( ptr, (int)fill, dim * sizeof(T) );
+} // amemalign
+
+// data, non-array types
+static inline forall( dtype T | sized(T) ) T * memset( T * dest, char c ) {
+	//printf( "X17\n" );
+	return memset( dest, c, sizeof(T) );
+} // memset
+extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
+static inline forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src ) {
+	//printf( "X18\n" );
+	return memcpy( dest, src, sizeof(T) );
+} // memcpy
+
+// data, array types
+static inline forall( dtype T | sized(T) ) T * amemset( 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 ) {
+	//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 );
-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 );
+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 );
 
 //---------------------------------------
@@ -77,12 +172,12 @@
 
 forall( otype T | { int ?<?( T, T ); } )
-T * bsearch( T key, const T * arr, size_t dimension );
-
-forall( otype T | { int ?<?( T, T ); } )
-unsigned int bsearch( T key, const T * arr, size_t dimension );
-
-
-forall( otype T | { int ?<?( T, T ); } )
-void qsort( const T * arr, size_t dimension );
+T * bsearch( T key, const T * arr, size_t dim );
+
+forall( otype T | { int ?<?( T, T ); } )
+unsigned int bsearch( T key, const T * arr, size_t dim );
+
+
+forall( otype T | { int ?<?( T, T ); } )
+void qsort( const T * arr, size_t dim );
 
 //---------------------------------------