Index: src/libcfa/stdlib
===================================================================
--- src/libcfa/stdlib	(revision ecae5860965de56ce3fadb77f1a7686686e37c67)
+++ src/libcfa/stdlib	(revision 1ddbf3b62f7b382b7646fdf54b247335ad770718)
@@ -10,11 +10,16 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jun  1 19:52:52 2018
-// Update Count     : 302
+// Last Modified On : Sat Jun  2 08:46:35 2018
+// Update Count     : 306
 //
 
 #pragma once
 
-#include <stdlib.h>										// strto*, *abs
+#include <stdlib.h>										// allocation, strto*, *abs
+extern "C" {
+	void * memalign( size_t align, size_t size );
+	void * aligned_alloc( size_t align, size_t size );
+	void * memset( void * dest, int c, size_t size );
+} // extern "C"
 
 //---------------------------------------
@@ -27,6 +32,7 @@
 //---------------------------------------
 
-// C dynamic allocation
 static inline forall( dtype T | sized(T) ) {
+	// C dynamic allocation
+
 	T * malloc( void ) {
 		// printf( "* malloc\n" );
@@ -51,5 +57,4 @@
 	} // realloc
 
-	extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void *
 	T * memalign( size_t align ) {
 		//printf( "X4\n" );
@@ -57,5 +62,4 @@
 	} // memalign
 
-	extern "C" { void * aligned_alloc( size_t align, size_t size ); } // use default C routine for void *
 	T * aligned_alloc( size_t align ) {
 		//printf( "X5\n" );
@@ -67,9 +71,7 @@
 		return posix_memalign( (void **)ptr, align, sizeof(T) ); // C posix_memalign
 	} // posix_memalign
-} // distribution
-
-// Cforall dynamic allocation
-static inline forall( dtype T | sized(T) ) {
-	extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *
+
+
+	// Cforall dynamic allocation
 
 	T * alloc( void ) {
@@ -104,45 +106,59 @@
 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 (T *)memset( ptr, (int)fill, sizeof(T) );
-} // align_alloc
-
-static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ) {
-	//printf( "X15\n" );
-	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( align, dim * sizeof(T) );
-    return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
-} // align_alloc
-
-
-// data, non-array types
-static inline forall( dtype T | sized(T) ) T * memset( T * dest, char c ) {
-	//printf( "X17\n" );
-	return (T *)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 (T *)memcpy( dest, src, sizeof(T) );
-} // memcpy
-
-// data, array types
-static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) {
-	//printf( "X19\n" );
-	return (T *)(void *)memset( dest, c, dim * sizeof(T) );	// C memset
-} // memset
-static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) {
-	//printf( "X20\n" );
-	return (T *)(void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
-} // memcpy
+
+static inline forall( dtype T | sized(T) ) {
+	T * align_alloc( size_t align ) {
+		//printf( "X13\n" );
+		return (T *)memalign( align, sizeof(T) );
+	} // align_alloc
+
+	T * align_alloc( size_t align, char fill ) {
+		//printf( "X14\n" );
+		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 ) {
+		//printf( "X15\n" );
+		return (T *)memalign( align, dim * sizeof(T) );
+	} // align_alloc
+
+	T * align_alloc( size_t align, size_t dim, char fill ) {
+		//printf( "X16\n" );
+		T * ptr = (T *)memalign( align, dim * sizeof(T) );
+		return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
+	} // align_alloc
+} // distribution
+
+
+static inline forall( dtype T | sized(T) ) {
+	// data, non-array types
+
+	T * memset( T * dest, char c ) {
+		//printf( "X17\n" );
+		return (T *)memset( dest, c, sizeof(T) );
+	} // memset
+
+	extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
+
+	T * memcpy( T * dest, const T * src ) {
+		//printf( "X18\n" );
+		return (T *)memcpy( dest, src, sizeof(T) );
+	} // memcpy
+} // distribution
+
+static inline forall( dtype T | sized(T) ) {
+	// data, array types
+
+	T * memset( T dest[], size_t dim, char c ) {
+		//printf( "X19\n" );
+		return (T *)(void *)memset( dest, c, dim * sizeof(T) );	// C memset
+	} // memset
+
+	T * memcpy( T dest[], const T src[], size_t dim ) {
+		//printf( "X20\n" );
+		return (T *)(void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
+	} // memcpy
+} // distribution
 
 // allocation/deallocation and constructor/destructor, non-array types
@@ -190,45 +206,23 @@
 //---------------------------------------
 
-forall( otype E | { int ?<?( E, E ); } )
-E * bsearch( E key, const E * vals, size_t dim );
-
-forall( otype E | { int ?<?( E, E ); } )
-size_t bsearch( E key, const E * vals, size_t dim );
-
-forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
-E * bsearch( K key, const E * vals, size_t dim );
-
-forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
-size_t bsearch( K key, const E * vals, size_t dim );
-
-
-forall( otype E | { int ?<?( E, E ); } )
-E * bsearchl( E key, const E * vals, size_t dim );
-
-forall( otype E | { int ?<?( E, E ); } )
-size_t bsearchl( E key, const E * vals, size_t dim );
-
-forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
-E * bsearchl( K key, const E * vals, size_t dim );
-
-forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
-size_t bsearchl( K key, const E * vals, size_t dim );
-
-
-forall( otype E | { int ?<?( E, E ); } )
-E * bsearchu( E key, const E * vals, size_t dim );
-
-forall( otype E | { int ?<?( E, E ); } )
-size_t bsearchu( E key, const E * vals, size_t dim );
-
-forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
-E * bsearchu( K key, const E * vals, size_t dim );
-
-forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
-size_t bsearchu( K key, const E * vals, size_t dim );
-
-
-forall( otype E | { int ?<?( E, E ); } )
-void qsort( E * vals, size_t dim );
+forall( otype E | { int ?<?( E, E ); } ) {
+	E * bsearch( E key, const E * vals, size_t dim );
+	size_t bsearch( E key, const E * vals, size_t dim );
+	E * bsearchl( E key, const E * vals, size_t dim );
+	size_t bsearchl( E key, const E * vals, size_t dim );
+	E * bsearchu( E key, const E * vals, size_t dim );
+	size_t bsearchu( E key, const E * vals, size_t dim );
+
+	void qsort( E * vals, size_t dim );
+} // distribution
+
+forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) {
+	E * bsearch( K key, const E * vals, size_t dim );
+	size_t bsearch( K key, const E * vals, size_t dim );
+	E * bsearchl( K key, const E * vals, size_t dim );
+	size_t bsearchl( K key, const E * vals, size_t dim );
+	E * bsearchu( K key, const E * vals, size_t dim );
+	size_t bsearchu( K key, const E * vals, size_t dim );
+} // distribution
 
 //---------------------------------------