Index: src/libcfa/stdlib.c
===================================================================
--- src/libcfa/stdlib.c	(revision 90c3b1c9b36943edd6040aac93c3da9265b218a4)
+++ src/libcfa/stdlib.c	(revision bd91e2afb6df92caef7c482fb7c8ab8a8a35bf42)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb 23 21:02:54 2016
-// Update Count     : 142
+// Last Modified On : Wed Mar  2 17:38:47 2016
+// Update Count     : 143
 //
 
@@ -27,22 +27,22 @@
 } // extern "C"
 
-forall( type T ) T * memset( T * ptr, unsigned char fill ) { // use default value '\0' for fill
+forall( otype T ) T * memset( T * ptr, unsigned char fill ) { // use default value '\0' for fill
 	printf( "memset1\n" );
     return (T *)memset( ptr, (int)fill, malloc_usable_size( ptr ) );
 } // memset
-forall( type T ) T * memset( T * ptr ) {				// remove when default value available
+forall( otype T ) T * memset( T * ptr ) {				// remove when default value available
 	printf( "memset2\n" );
     return (T *)memset( ptr, 0, malloc_usable_size( ptr ) );
 } // memset
 
-forall( type T ) T * malloc( void ) {
+forall( otype T ) T * malloc( void ) {
 	printf( "malloc1\n" );
     return (T *)malloc( sizeof(T) );
 } // malloc
-forall( type T ) T * malloc( size_t size ) {
+forall( otype T ) T * malloc( size_t size ) {
 	printf( "malloc2\n" );
     return (T *)(void *)malloc( size );
 } // malloc
-forall( type T ) T * malloc( char fill ) {
+forall( otype T ) T * malloc( char fill ) {
 	printf( "malloc3\n" );
 	T * ptr = (T *)malloc( sizeof(T) );
@@ -50,14 +50,14 @@
 } // malloc
 
-forall( type T ) T * calloc( size_t size ) {
+forall( otype T ) T * calloc( size_t size ) {
 	printf( "calloc\n" );
     return (T *)calloc( size, sizeof(T) );
 } // calloc
 
-forall( type T ) T * realloc( T * ptr, size_t size ) {
+forall( otype T ) T * realloc( T * ptr, size_t size ) {
 	printf( "realloc1\n" );
     return (T *)(void *)realloc( (void *)ptr, size );
 } // realloc
-forall( type T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
+forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
 	printf( "realloc2\n" );
     char * nptr = (T *)(void *)realloc( (void *)ptr, size );
@@ -67,24 +67,24 @@
 } // realloc
 
-forall( type T ) T * malloc( T * ptr, size_t size ) {
+forall( otype T ) T * malloc( T * ptr, size_t size ) {
 	printf( "malloc4\n" );
     return (T *)realloc( ptr, size );
 } // malloc
-forall( type T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
+forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
 	printf( "malloc5\n" );
     return (T *)realloc( ptr, size, fill );
 } // malloc
 
-forall( type T ) T * aligned_alloc( size_t alignment ) {
+forall( otype T ) T * aligned_alloc( size_t alignment ) {
 	printf( "aligned_alloc\n" );
     return (T *)memalign( alignment, sizeof(T) );
 } // aligned_alloc
 
-forall( type T ) T * memalign( size_t alignment ) {
+forall( otype T ) T * memalign( size_t alignment ) {
 	printf( "memalign\n" );
     return (T *)memalign( alignment, sizeof(T) );
 } // memalign
 
-forall( type T ) int posix_memalign( T ** ptr, size_t alignment ) {
+forall( otype T ) int posix_memalign( T ** ptr, size_t alignment ) {
 	printf( "posix_memalign\n" );
     return posix_memalign( (void **)ptr, alignment, sizeof(T) );
@@ -212,5 +212,5 @@
 //---------------------------------------
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 T * bsearch( const T key, const T * arr, size_t dimension ) {
 	int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
@@ -218,5 +218,5 @@
 } // bsearch
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 void qsort( const T * arr, size_t dimension ) {
 	int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
@@ -226,5 +226,5 @@
 //---------------------------------------
 
-forall( type T | { T ?/?( T, T ); T ?%?( T, T ); } )
+forall( otype T | { T ?/?( T, T ); T ?%?( T, T ); } )
 [ T, T ] div( T t1, T t2 ) { /* return [ t1 / t2, t1 % t2 ]; */ }
 
@@ -257,15 +257,15 @@
 //---------------------------------------
 
-forall( type T | { int ?<?( T, T ); } )
+forall( otype T | { int ?<?( T, T ); } )
 T min( const T t1, const T t2 ) {
 	return t1 < t2 ? t1 : t2;
 } // min
 
-forall( type T | { int ?>?( T, T ); } )
+forall( otype T | { int ?>?( T, T ); } )
 T max( const T t1, const T t2 ) {
 	return t1 > t2 ? t1 : t2;
 } // max
 
-forall( type T )
+forall( otype T )
 void swap( T * t1, T * t2 ) {
 	T temp = *t1;
