Index: libcfa/src/assert.cfa
===================================================================
--- libcfa/src/assert.cfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/assert.cfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Nov 21 17:09:26 2019
-// Update Count     : 5
+// Last Modified On : Tue Feb  4 13:00:18 2020
+// Update Count     : 6
 //
 
@@ -26,5 +26,5 @@
 
 	// called by macro assert in assert.h
-	void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) {
+	void __assert_fail( const char assertion[], const char file[], unsigned int line, const char function[] ) {
 		__cfaabi_bits_print_safe( STDERR_FILENO, CFA_ASSERT_FMT ".\n", assertion, __progname, function, line, file );
 		abort();
@@ -32,5 +32,5 @@
 
 	// called by macro assertf
-	void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) {
+	void __assert_fail_f( const char assertion[], const char file[], unsigned int line, const char function[], const char fmt[], ... ) {
 		__cfaabi_bits_acquire();
 		__cfaabi_bits_print_nolock( STDERR_FILENO, CFA_ASSERT_FMT ": ", assertion, __progname, function, line, file );
Index: libcfa/src/bits/debug.cfa
===================================================================
--- libcfa/src/bits/debug.cfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/bits/debug.cfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Thu Mar 30 12:30:01 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Nov 21 17:16:30 2019
-// Update Count     : 10
+// Last Modified On : Tue Feb  4 13:03:16 2020
+// Update Count     : 11
 //
 
@@ -27,6 +27,5 @@
 
 extern "C" {
-
-	void __cfaabi_bits_write( int fd, const char *in_buffer, int len ) {
+	void __cfaabi_bits_write( int fd, const char in_buffer[], int len ) {
 		// ensure all data is written
 		for ( int count = 0, retcode; count < len; count += retcode ) {
Index: libcfa/src/bits/debug.hfa
===================================================================
--- libcfa/src/bits/debug.hfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/bits/debug.hfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Nov 21 17:06:58 2019
-// Update Count     : 8
+// Last Modified On : Tue Feb  4 12:29:21 2020
+// Update Count     : 9
 //
 
@@ -21,6 +21,6 @@
 	#define __cfaabi_dbg_ctx __PRETTY_FUNCTION__
 	#define __cfaabi_dbg_ctx2 , __PRETTY_FUNCTION__
-	#define __cfaabi_dbg_ctx_param const char * caller
-	#define __cfaabi_dbg_ctx_param2 , const char * caller
+	#define __cfaabi_dbg_ctx_param const char caller[]
+	#define __cfaabi_dbg_ctx_param2 , const char caller[]
 #else
 	#define __cfaabi_dbg_debug_do(...)
@@ -38,5 +38,5 @@
 	#include <stdio.h>
 
-	extern void __cfaabi_bits_write( int fd, const char *buffer, int len );
+	extern void __cfaabi_bits_write( int fd, const char buffer[], int len );
 	extern void __cfaabi_bits_acquire();
 	extern void __cfaabi_bits_release();
Index: libcfa/src/bits/locks.hfa
===================================================================
--- libcfa/src/bits/locks.hfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/bits/locks.hfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Tue Oct 31 15:14:38 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Aug 11 15:42:24 2018
-// Update Count     : 10
+// Last Modified On : Tue Feb  4 13:03:19 2020
+// Update Count     : 11
 //
 
@@ -54,5 +54,5 @@
 
 		#ifdef __CFA_DEBUG__
-			void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name);
+			void __cfaabi_dbg_record(__spinlock_t & this, const char prev_name[]);
 		#else
 			#define __cfaabi_dbg_record(x, y)
Index: libcfa/src/concurrency/coroutine.cfa
===================================================================
--- libcfa/src/concurrency/coroutine.cfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/concurrency/coroutine.cfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Dec  5 14:37:29 2019
-// Update Count     : 15
+// Last Modified On : Tue Feb  4 12:29:25 2020
+// Update Count     : 16
 //
 
@@ -89,5 +89,5 @@
 }
 
-void ?{}( coroutine_desc & this, const char * name, void * storage, size_t storageSize ) with( this ) {
+void ?{}( coroutine_desc & this, const char name[], void * storage, size_t storageSize ) with( this ) {
 	(this.context){0p, 0p};
 	(this.stack){storage, storageSize};
Index: libcfa/src/concurrency/coroutine.hfa
===================================================================
--- libcfa/src/concurrency/coroutine.hfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/concurrency/coroutine.hfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Dec  3 22:47:58 2019
-// Update Count     : 10
+// Last Modified On : Tue Feb  4 12:29:26 2020
+// Update Count     : 11
 //
 
@@ -35,5 +35,5 @@
 // void ^?{}( coStack_t & this );
 
-void ?{}( coroutine_desc & this, const char * name, void * storage, size_t storageSize );
+void ?{}( coroutine_desc & this, const char name[], void * storage, size_t storageSize );
 void ^?{}( coroutine_desc & this );
 
@@ -41,6 +41,6 @@
 static inline void ?{}( coroutine_desc & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
 static inline void ?{}( coroutine_desc & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
-static inline void ?{}( coroutine_desc & this, const char * name)                    { this{ name, 0p, 0 }; }
-static inline void ?{}( coroutine_desc & this, const char * name, size_t stackSize ) { this{ name, 0p, stackSize }; }
+static inline void ?{}( coroutine_desc & this, const char name[])                    { this{ name, 0p, 0 }; }
+static inline void ?{}( coroutine_desc & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
 
 //-----------------------------------------------------------------------------
Index: libcfa/src/concurrency/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/concurrency/kernel.cfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jan 30 22:55:50 2020
-// Update Count     : 56
+// Last Modified On : Tue Feb  4 13:03:15 2020
+// Update Count     : 58
 //
 
@@ -209,5 +209,5 @@
 
 static void start(processor * this);
-void ?{}(processor & this, const char * name, cluster & cltr) with( this ) {
+void ?{}(processor & this, const char name[], cluster & cltr) with( this ) {
 	this.name = name;
 	this.cltr = &cltr;
@@ -238,5 +238,5 @@
 }
 
-void ?{}(cluster & this, const char * name, Duration preemption_rate) with( this ) {
+void ?{}(cluster & this, const char name[], Duration preemption_rate) with( this ) {
 	this.name = name;
 	this.preemption_rate = preemption_rate;
@@ -441,5 +441,5 @@
 }
 
-static void Abort( int ret, const char * func ) {
+static void Abort( int ret, const char func[] ) {
 	if ( ret ) {										// pthread routines return errno values
 		abort( "%s : internal error, error(%d) %s.", func, ret, strerror( ret ) );
@@ -978,5 +978,5 @@
 __cfaabi_dbg_debug_do(
 	extern "C" {
-		void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name) {
+		void __cfaabi_dbg_record(__spinlock_t & this, const char prev_name[]) {
 			this.prev_name = prev_name;
 			this.prev_thrd = kernelTLS.this_thread;
Index: libcfa/src/concurrency/kernel.hfa
===================================================================
--- libcfa/src/concurrency/kernel.hfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/concurrency/kernel.hfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Dec  4 07:54:51 2019
-// Update Count     : 18
+// Last Modified On : Tue Feb  4 12:29:26 2020
+// Update Count     : 22
 //
 
@@ -150,10 +150,10 @@
 };
 
-void  ?{}(processor & this, const char * name, struct cluster & cltr);
+void  ?{}(processor & this, const char name[], struct cluster & cltr);
 void ^?{}(processor & this);
 
 static inline void  ?{}(processor & this)                    { this{ "Anonymous Processor", *mainCluster}; }
 static inline void  ?{}(processor & this, struct cluster & cltr)    { this{ "Anonymous Processor", cltr}; }
-static inline void  ?{}(processor & this, const char * name) { this{name, *mainCluster }; }
+static inline void  ?{}(processor & this, const char name[]) { this{name, *mainCluster }; }
 
 static inline [processor *&, processor *& ] __get( processor & this ) {
@@ -195,10 +195,10 @@
 extern Duration default_preemption();
 
-void ?{} (cluster & this, const char * name, Duration preemption_rate);
+void ?{} (cluster & this, const char name[], Duration preemption_rate);
 void ^?{}(cluster & this);
 
 static inline void ?{} (cluster & this)                           { this{"Anonymous Cluster", default_preemption()}; }
 static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }
-static inline void ?{} (cluster & this, const char * name)        { this{name, default_preemption()}; }
+static inline void ?{} (cluster & this, const char name[])        { this{name, default_preemption()}; }
 
 static inline [cluster *&, cluster *& ] __get( cluster & this ) {
Index: libcfa/src/fstream.cfa
===================================================================
--- libcfa/src/fstream.cfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/fstream.cfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Nov 29 06:56:46 2019
-// Update Count     : 355
+// Last Modified On : Tue Feb  4 11:55:29 2020
+// Update Count     : 356
 //
 
@@ -48,5 +48,5 @@
 void sepReset( ofstream & os, bool reset ) { os.sepDefault = reset; os.sepOnOff = os.sepDefault; }
 const char * sepGetCur( ofstream & os ) { return os.sepCur; }
-void sepSetCur( ofstream & os, const char * sepCur ) { os.sepCur = sepCur; }
+void sepSetCur( ofstream & os, const char sepCur[] ) { os.sepCur = sepCur; }
 bool getNL( ofstream & os ) { return os.sawNL; }
 void setNL( ofstream & os, bool state ) { os.sawNL = state; }
@@ -58,9 +58,9 @@
 void ?{}( ofstream & os ) { os.file = 0; }
 
-void ?{}( ofstream & os, const char * name, const char * mode ) {
+void ?{}( ofstream & os, const char name[], const char mode[] ) {
 	open( os, name, mode );
 } // ?{}
 
-void ?{}( ofstream & os, const char * name ) {
+void ?{}( ofstream & os, const char name[] ) {
 	open( os, name, "w" );
 } // ?{}
@@ -91,5 +91,5 @@
 
 const char * sepGet( ofstream & os ) { return os.separator; }
-void sepSet( ofstream & os, const char * s ) {
+void sepSet( ofstream & os, const char s[] ) {
 	assert( s );
 	strncpy( os.separator, s, sepSize - 1 );
@@ -98,5 +98,5 @@
 
 const char * sepGetTuple( ofstream & os ) { return os.tupleSeparator; }
-void sepSetTuple( ofstream & os, const char * s ) {
+void sepSetTuple( ofstream & os, const char s[] ) {
 	assert( s );
 	strncpy( os.tupleSeparator, s, sepSize - 1 );
@@ -119,5 +119,5 @@
 } // flush
 
-void open( ofstream & os, const char * name, const char * mode ) {
+void open( ofstream & os, const char name[], const char mode[] ) {
 	FILE * file = fopen( name, mode );
 	#ifdef __CFA_DEBUG__
@@ -129,5 +129,5 @@
 } // open
 
-void open( ofstream & os, const char * name ) {
+void open( ofstream & os, const char name[] ) {
 	open( os, name, "w" );
 } // open
@@ -141,5 +141,5 @@
 } // close
 
-ofstream & write( ofstream & os, const char * data, size_t size ) {
+ofstream & write( ofstream & os, const char data[], size_t size ) {
 	if ( fail( os ) ) {
 		abort | IO_MSG "attempt write I/O on failed stream";
@@ -191,9 +191,9 @@
 void ?{}( ifstream & is ) {	is.file = 0; }
 
-void ?{}( ifstream & is, const char * name, const char * mode ) {
+void ?{}( ifstream & is, const char name[], const char mode[] ) {
 	open( is, name, mode );
 } // ?{}
 
-void ?{}( ifstream & is, const char * name ) {
+void ?{}( ifstream & is, const char name[] ) {
 	open( is, name, "r" );
 } // ?{}
@@ -215,5 +215,5 @@
 } // eof
 
-void open( ifstream & is, const char * name, const char * mode ) {
+void open( ifstream & is, const char name[], const char mode[] ) {
 	FILE * file = fopen( name, mode );
 	#ifdef __CFA_DEBUG__
@@ -225,5 +225,5 @@
 } // open
 
-void open( ifstream & is, const char * name ) {
+void open( ifstream & is, const char name[] ) {
 	open( is, name, "r" );
 } // open
Index: libcfa/src/fstream.hfa
===================================================================
--- libcfa/src/fstream.hfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/fstream.hfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Nov 29 06:56:02 2019
-// Update Count     : 168
+// Last Modified On : Tue Feb  4 13:03:17 2020
+// Update Count     : 172
 //
 
@@ -40,5 +40,5 @@
 void sepReset( ofstream &, bool );
 const char * sepGetCur( ofstream & );
-void sepSetCur( ofstream &, const char * );
+void sepSetCur( ofstream &, const char [] );
 bool getNL( ofstream & );
 void setNL( ofstream &, bool );
@@ -56,20 +56,20 @@
 
 const char * sepGet( ofstream & );
-void sepSet( ofstream &, const char * );
+void sepSet( ofstream &, const char [] );
 const char * sepGetTuple( ofstream & );
-void sepSetTuple( ofstream &, const char * );
+void sepSetTuple( ofstream &, const char [] );
 
 void ends( ofstream & os );
 int fail( ofstream & );
 int flush( ofstream & );
-void open( ofstream &, const char * name, const char * mode );
-void open( ofstream &, const char * name );
+void open( ofstream &, const char name[], const char mode[] );
+void open( ofstream &, const char name[] );
 void close( ofstream & );
-ofstream & write( ofstream &, const char * data, size_t size );
+ofstream & write( ofstream &, const char data[], size_t size );
 int fmt( ofstream &, const char format[], ... );
 
 void ?{}( ofstream & os );
-void ?{}( ofstream & os, const char * name, const char * mode );
-void ?{}( ofstream & os, const char * name );
+void ?{}( ofstream & os, const char name[], const char mode[] );
+void ?{}( ofstream & os, const char name[] );
 void ^?{}( ofstream & os );
 
@@ -92,6 +92,6 @@
 int fail( ifstream & is );
 int eof( ifstream & is );
-void open( ifstream & is, const char * name, const char * mode );
-void open( ifstream & is, const char * name );
+void open( ifstream & is, const char name[], const char mode[] );
+void open( ifstream & is, const char name[] );
 void close( ifstream & is );
 ifstream & read( ifstream & is, char * data, size_t size );
@@ -100,6 +100,6 @@
 
 void ?{}( ifstream & is );
-void ?{}( ifstream & is, const char * name, const char * mode );
-void ?{}( ifstream & is, const char * name );
+void ?{}( ifstream & is, const char name[], const char mode[] );
+void ?{}( ifstream & is, const char name[] );
 void ^?{}( ifstream & is );
 
Index: libcfa/src/gmp.hfa
===================================================================
--- libcfa/src/gmp.hfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/gmp.hfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Tue Apr 19 08:43:43 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 13 15:25:05 2019
-// Update Count     : 27
+// Last Modified On : Tue Feb  4 11:55:07 2020
+// Update Count     : 28
 //
 
@@ -31,5 +31,5 @@
 	void ?{}( Int & this, signed long int init ) { mpz_init_set_si( this.mpz, init ); }
 	void ?{}( Int & this, unsigned long int init ) { mpz_init_set_ui( this.mpz, init ); }
-	void ?{}( Int & this, const char * val ) { if ( mpz_init_set_str( this.mpz, val, 0 ) ) abort(); }
+	void ?{}( Int & this, const char val[] ) { if ( mpz_init_set_str( this.mpz, val, 0 ) ) abort(); }
 	void ^?{}( Int & this ) { mpz_clear( this.mpz ); }
 
@@ -37,5 +37,5 @@
 	Int ?`mp( signed long int init ) { return (Int){ init }; }
 	Int ?`mp( unsigned long int init ) { return (Int){ init }; }
-	Int ?`mp( const char * init ) { return (Int){ init }; }
+	Int ?`mp( const char init[] ) { return (Int){ init }; }
 
 	// assignment
@@ -43,5 +43,5 @@
 	Int ?=?( Int & lhs, long int rhs ) { mpz_set_si( lhs.mpz, rhs ); return lhs; }
 	Int ?=?( Int & lhs, unsigned long int rhs ) { mpz_set_ui( lhs.mpz, rhs ); return lhs; }
-	Int ?=?( Int & lhs, const char * rhs ) { if ( mpz_set_str( lhs.mpz, rhs, 0 ) ) { abort | "invalid string conversion"; } return lhs; }
+	Int ?=?( Int & lhs, const char rhs[] ) { if ( mpz_set_str( lhs.mpz, rhs, 0 ) ) { abort | "invalid string conversion"; } return lhs; }
 
 	char ?=?( char & lhs, Int rhs ) { char val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
Index: libcfa/src/heap.cfa
===================================================================
--- libcfa/src/heap.cfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/heap.cfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Dec  8 21:01:31 2019
-// Update Count     : 647
+// Last Modified On : Tue Feb  4 10:04:51 2020
+// Update Count     : 648
 //
 
@@ -380,5 +380,5 @@
 
 
-static inline void checkHeader( bool check, const char * name, void * addr ) {
+static inline void checkHeader( bool check, const char name[], void * addr ) {
 	if ( unlikely( check ) ) {							// bad address ?
 		abort( "Attempt to %s storage %p with address outside the heap.\n"
@@ -418,5 +418,5 @@
 
 
-static inline bool headers( const char * name __attribute__(( unused )), void * addr, HeapManager.Storage.Header *& header, HeapManager.FreeHeader *& freeElem, size_t & size, size_t & alignment ) with ( heapManager ) {
+static inline bool headers( const char name[] __attribute__(( unused )), void * addr, HeapManager.Storage.Header *& header, HeapManager.FreeHeader *& freeElem, size_t & size, size_t & alignment ) with ( heapManager ) {
 	header = headerAddr( addr );
 
Index: libcfa/src/iostream.cfa
===================================================================
--- libcfa/src/iostream.cfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/iostream.cfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 13 08:07:59 2019
-// Update Count     : 821
+// Last Modified On : Tue Feb  4 10:07:17 2020
+// Update Count     : 822
 //
 
@@ -237,5 +237,5 @@
 	} // ?|?
 
-	ostype & ?|?( ostype & os, const char * str ) {
+	ostype & ?|?( ostype & os, const char str[] ) {
 		enum { Open = 1, Close, OpenClose };
 		static const unsigned char mask[256] @= {
@@ -275,5 +275,6 @@
 		return write( os, str, len );
 	} // ?|?
-	void ?|?( ostype & os, const char * str ) {
+
+	void ?|?( ostype & os, const char str[] ) {
 		(ostype &)(os | str); ends( os );
 	} // ?|?
@@ -536,4 +537,5 @@
 		return os; \
 	} /* ?|? */ \
+\
 	void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \
 } // distribution
@@ -571,4 +573,5 @@
 		return os;
 	} // ?|?
+
 	void ?|?( ostype & os, _Ostream_Manip(char) f ) { (ostype &)(os | f); ends( os ); }
 } // distribution
@@ -616,4 +619,5 @@
 		return os;
 	} // ?|?
+
 	void ?|?( ostype & os, _Ostream_Manip(const char *) f ) { (ostype &)(os | f); ends( os ); }
 } // distribution
@@ -735,5 +739,5 @@
 	} // ?|?
 
-	// istype & ?|?( istype & is, const char * fmt ) {
+	// istype & ?|?( istype & is, const char fmt[] ) {
 	// 	fmt( is, fmt, "" );
 	// 	return is;
Index: libcfa/src/iostream.hfa
===================================================================
--- libcfa/src/iostream.hfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/iostream.hfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 12 12:08:38 2019
-// Update Count     : 334
+// Last Modified On : Tue Feb  4 11:55:28 2020
+// Update Count     : 335
 //
 
@@ -28,5 +28,5 @@
 	void sepReset( ostype &, bool );					// set separator and default state
 	const char * sepGetCur( ostype & );					// get current separator string
-	void sepSetCur( ostype &, const char * );			// set current separator string
+	void sepSetCur( ostype &, const char [] );			// set current separator string
 	bool getNL( ostype & );								// check newline
 	void setNL( ostype &, bool );						// saw newline
@@ -43,14 +43,14 @@
 
 	const char * sepGet( ostype & );					// get separator string
-	void sepSet( ostype &, const char * );				// set separator to string (15 character maximum)
+	void sepSet( ostype &, const char [] );				// set separator to string (15 character maximum)
 	const char * sepGetTuple( ostype & );				// get tuple separator string
-	void sepSetTuple( ostype &, const char * );			// set tuple separator to string (15 character maximum)
+	void sepSetTuple( ostype &, const char [] );		// set tuple separator to string (15 character maximum)
 
 	void ends( ostype & os );							// end of output statement
 	int fail( ostype & );
 	int flush( ostype & );
-	void open( ostype & os, const char * name, const char * mode );
+	void open( ostype & os, const char name[], const char mode[] );
 	void close( ostype & os );
-	ostype & write( ostype &, const char *, size_t );
+	ostype & write( ostype &, const char [], size_t );
 	int fmt( ostype &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
 }; // ostream
@@ -113,6 +113,6 @@
 	void ?|?( ostype &, long double _Complex );
 
-	ostype & ?|?( ostype &, const char * );
-	void ?|?( ostype &, const char * );
+	ostype & ?|?( ostype &, const char [] );
+	void ?|?( ostype &, const char [] );
 	// ostype & ?|?( ostype &, const char16_t * );
 #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
@@ -256,9 +256,9 @@
 
 static inline {
-	_Ostream_Manip(const char *) bin( const char * s ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'b', { .all : 0 } }; }
-	_Ostream_Manip(const char *) oct( const char * s ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'o', { .all : 0 } }; }
-	_Ostream_Manip(const char *) hex( const char * s ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'x', { .all : 0 } }; }
-	_Ostream_Manip(const char *) wd( unsigned int w, const char * s ) { return (_Ostream_Manip(const char *))@{ s, w, 0, 's', { .all : 0 } }; }
-	_Ostream_Manip(const char *) wd( unsigned int w, unsigned char pc, const char * s ) { return (_Ostream_Manip(const char *))@{ s, w, pc, 's', { .flags.pc : true } }; }
+	_Ostream_Manip(const char *) bin( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'b', { .all : 0 } }; }
+	_Ostream_Manip(const char *) oct( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'o', { .all : 0 } }; }
+	_Ostream_Manip(const char *) hex( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'x', { .all : 0 } }; }
+	_Ostream_Manip(const char *) wd( unsigned int w, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, 0, 's', { .all : 0 } }; }
+	_Ostream_Manip(const char *) wd( unsigned int w, unsigned char pc, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, pc, 's', { .flags.pc : true } }; }
 	_Ostream_Manip(const char *) & wd( unsigned int w, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; return fmt; }
 	_Ostream_Manip(const char *) & wd( unsigned int w, unsigned char pc, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; }
@@ -281,5 +281,5 @@
 	int fail( istype & );
 	int eof( istype & );
-	void open( istype & is, const char * name );
+	void open( istype & is, const char name[] );
 	void close( istype & is );
 	istype & read( istype &, char *, size_t );
@@ -316,5 +316,5 @@
 	istype & ?|?( istype &, long double _Complex & );
 
-//	istype & ?|?( istype &, const char * );
+//	istype & ?|?( istype &, const char [] );
 	istype & ?|?( istype &, char * );
 
@@ -343,12 +343,12 @@
 static inline {
 	_Istream_Cstr skip( unsigned int n ) { return (_Istream_Cstr){ 0p, 0p, n, { .all : 0 } }; }
-	_Istream_Cstr skip( const char * scanset ) { return (_Istream_Cstr){ 0p, scanset, -1, { .all : 0 } }; }
-	_Istream_Cstr incl( const char * scanset, char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : false } }; }
-	_Istream_Cstr & incl( const char * scanset, _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
-	_Istream_Cstr excl( const char * scanset, char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : true } }; }
-	_Istream_Cstr & excl( const char * scanset, _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = true; return fmt; }
-	_Istream_Cstr ignore( const char * s ) { return (_Istream_Cstr)@{ s, 0p, -1, { .flags.ignore : true } }; }
+	_Istream_Cstr skip( const char scanset[] ) { return (_Istream_Cstr){ 0p, scanset, -1, { .all : 0 } }; }
+	_Istream_Cstr incl( const char scanset[], char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : false } }; }
+	_Istream_Cstr & incl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
+	_Istream_Cstr excl( const char scanset[], char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : true } }; }
+	_Istream_Cstr & excl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = true; return fmt; }
+	_Istream_Cstr ignore( const char s[] ) { return (_Istream_Cstr)@{ s, 0p, -1, { .flags.ignore : true } }; }
 	_Istream_Cstr & ignore( _Istream_Cstr & fmt ) { fmt.flags.ignore = true; return fmt; }
-	_Istream_Cstr wdi( unsigned int w, char * s ) { return (_Istream_Cstr)@{ s, 0p, w, { .all : 0 } }; }
+	_Istream_Cstr wdi( unsigned int w, char s[] ) { return (_Istream_Cstr)@{ s, 0p, w, { .all : 0 } }; }
 	_Istream_Cstr & wdi( unsigned int w, _Istream_Cstr & fmt ) { fmt.wd = w; return fmt; }
 } // distribution
Index: libcfa/src/math.hfa
===================================================================
--- libcfa/src/math.hfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/math.hfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Mon Apr 18 23:37:04 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 13 11:02:15 2018
-// Update Count     : 116
+// Last Modified On : Tue Feb  4 10:27:11 2020
+// Update Count     : 117
 //
 
@@ -51,7 +51,7 @@
 static inline long double fdim( long double x, long double y ) { return fdiml( x, y ); }
 
-static inline float nan( const char * tag ) { return nanf( tag ); }
-// extern "C" { double nan( const char * ); }
-static inline long double nan( const char * tag ) { return nanl( tag ); }
+static inline float nan( const char tag[] ) { return nanf( tag ); }
+// extern "C" { double nan( const char [] ); }
+static inline long double nan( const char tag[] ) { return nanl( tag ); }
 
 //---------------------- Exponential ----------------------
Index: libcfa/src/startup.cfa
===================================================================
--- libcfa/src/startup.cfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/startup.cfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Tue Jul 24 16:21:57 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Dec 13 13:16:45 2019
-// Update Count     : 29
+// Last Modified On : Tue Feb  4 13:03:18 2020
+// Update Count     : 30
 //
 
@@ -41,5 +41,5 @@
 struct __spinlock_t;
 extern "C" {
-	void __cfaabi_dbg_record(struct __spinlock_t & this, const char * prev_name) __attribute__(( weak )) {}
+	void __cfaabi_dbg_record(struct __spinlock_t & this, const char prev_name[]) __attribute__(( weak )) {}
 }
 
Index: libcfa/src/stdhdr/assert.h
===================================================================
--- libcfa/src/stdhdr/assert.h	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/stdhdr/assert.h	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Mon Jul  4 23:25:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jul 31 23:09:32 2017
-// Update Count     : 13
+// Last Modified On : Tue Feb  4 12:58:49 2020
+// Update Count     : 15
 //
 
@@ -27,5 +27,5 @@
 	#define assertf( expr, fmt, ... ) ((expr) ? ((void)0) : __assert_fail_f(__VSTRINGIFY__(expr), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, ## __VA_ARGS__ ))
 
-	void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) __attribute__((noreturn, format( printf, 5, 6) ));
+	void __assert_fail_f( const char assertion[], const char file[], unsigned int line, const char function[], const char fmt[], ... ) __attribute__((noreturn, format( printf, 5, 6) ));
 #endif
 
Index: libcfa/src/stdlib.cfa
===================================================================
--- libcfa/src/stdlib.cfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/stdlib.cfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Nov 20 17:22:47 2019
-// Update Count     : 485
+// Last Modified On : Tue Feb  4 08:27:08 2020
+// Update Count     : 486
 //
 
@@ -107,5 +107,5 @@
 //---------------------------------------
 
-float _Complex strto( const char * sptr, char ** eptr ) {
+float _Complex strto( const char sptr[], char ** eptr ) {
 	float re, im;
 	char * eeptr;
@@ -118,5 +118,5 @@
 } // strto
 
-double _Complex strto( const char * sptr, char ** eptr ) {
+double _Complex strto( const char sptr[], char ** eptr ) {
 	double re, im;
 	char * eeptr;
@@ -129,5 +129,5 @@
 } // strto
 
-long double _Complex strto( const char * sptr, char ** eptr ) {
+long double _Complex strto( const char sptr[], char ** eptr ) {
 	long double re, im;
 	char * eeptr;
Index: libcfa/src/stdlib.hfa
===================================================================
--- libcfa/src/stdlib.hfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/stdlib.hfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Nov 29 23:08:02 2019
-// Update Count     : 400
+// Last Modified On : Tue Feb  4 08:27:01 2020
+// Update Count     : 401
 //
 
@@ -193,35 +193,35 @@
 
 static inline {
-	int strto( const char * sptr, char ** eptr, int base ) { return (int)strtol( sptr, eptr, base ); }
-	unsigned int strto( const char * sptr, char ** eptr, int base ) { return (unsigned int)strtoul( sptr, eptr, base ); }
-	long int strto( const char * sptr, char ** eptr, int base ) { return strtol( sptr, eptr, base ); }
-	unsigned long int strto( const char * sptr, char ** eptr, int base ) { return strtoul( sptr, eptr, base ); }
-	long long int strto( const char * sptr, char ** eptr, int base ) { return strtoll( sptr, eptr, base ); }
-	unsigned long long int strto( const char * sptr, char ** eptr, int base ) { return strtoull( sptr, eptr, base ); }
-
-	float strto( const char * sptr, char ** eptr ) { return strtof( sptr, eptr ); }
-	double strto( const char * sptr, char ** eptr ) { return strtod( sptr, eptr ); }
-	long double strto( const char * sptr, char ** eptr ) { return strtold( sptr, eptr ); }
-} // distribution
-
-float _Complex strto( const char * sptr, char ** eptr );
-double _Complex strto( const char * sptr, char ** eptr );
-long double _Complex strto( const char * sptr, char ** eptr );
+	int strto( const char sptr[], char ** eptr, int base ) { return (int)strtol( sptr, eptr, base ); }
+	unsigned int strto( const char sptr[], char ** eptr, int base ) { return (unsigned int)strtoul( sptr, eptr, base ); }
+	long int strto( const char sptr[], char ** eptr, int base ) { return strtol( sptr, eptr, base ); }
+	unsigned long int strto( const char sptr[], char ** eptr, int base ) { return strtoul( sptr, eptr, base ); }
+	long long int strto( const char sptr[], char ** eptr, int base ) { return strtoll( sptr, eptr, base ); }
+	unsigned long long int strto( const char sptr[], char ** eptr, int base ) { return strtoull( sptr, eptr, base ); }
+
+	float strto( const char sptr[], char ** eptr ) { return strtof( sptr, eptr ); }
+	double strto( const char sptr[], char ** eptr ) { return strtod( sptr, eptr ); }
+	long double strto( const char sptr[], char ** eptr ) { return strtold( sptr, eptr ); }
+} // distribution
+
+float _Complex strto( const char sptr[], char ** eptr );
+double _Complex strto( const char sptr[], char ** eptr );
+long double _Complex strto( const char sptr[], char ** eptr );
 
 static inline {
-	int ato( const char * sptr ) { return (int)strtol( sptr, 0p, 10 ); }
-	unsigned int ato( const char * sptr ) { return (unsigned int)strtoul( sptr, 0p, 10 ); }
-	long int ato( const char * sptr ) { return strtol( sptr, 0p, 10 ); }
-	unsigned long int ato( const char * sptr ) { return strtoul( sptr, 0p, 10 ); }
-	long long int ato( const char * sptr ) { return strtoll( sptr, 0p, 10 ); }
-	unsigned long long int ato( const char * sptr ) { return strtoull( sptr, 0p, 10 ); }
-
-	float ato( const char * sptr ) { return strtof( sptr, 0p ); }
-	double ato( const char * sptr ) { return strtod( sptr, 0p ); }
-	long double ato( const char * sptr ) { return strtold( sptr, 0p ); }
-
-	float _Complex ato( const char * sptr ) { return strto( sptr, 0p ); }
-	double _Complex ato( const char * sptr ) { return strto( sptr, 0p ); }
-	long double _Complex ato( const char * sptr ) { return strto( sptr, 0p ); }
+	int ato( const char sptr[] ) { return (int)strtol( sptr, 0p, 10 ); }
+	unsigned int ato( const char sptr[] ) { return (unsigned int)strtoul( sptr, 0p, 10 ); }
+	long int ato( const char sptr[] ) { return strtol( sptr, 0p, 10 ); }
+	unsigned long int ato( const char sptr[] ) { return strtoul( sptr, 0p, 10 ); }
+	long long int ato( const char sptr[] ) { return strtoll( sptr, 0p, 10 ); }
+	unsigned long long int ato( const char sptr[] ) { return strtoull( sptr, 0p, 10 ); }
+
+	float ato( const char sptr[] ) { return strtof( sptr, 0p ); }
+	double ato( const char sptr[] ) { return strtod( sptr, 0p ); }
+	long double ato( const char sptr[] ) { return strtold( sptr, 0p ); }
+
+	float _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); }
+	double _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); }
+	long double _Complex ato( const char sptr[] ) { return strto( sptr, 0p ); }
 } // distribution
 
Index: libcfa/src/time.cfa
===================================================================
--- libcfa/src/time.cfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/time.cfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Tue Mar 27 13:33:14 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Jan  5 17:27:40 2020
-// Update Count     : 69
+// Last Modified On : Tue Feb  4 08:24:18 2020
+// Update Count     : 70
 //
 
@@ -129,5 +129,5 @@
 } // dd_mm_yy
 
-size_t strftime( char * buf, size_t size, const char * fmt, Time time ) with( time ) {
+size_t strftime( char buf[], size_t size, const char fmt[], Time time ) with( time ) {
 	time_t s = tn / TIMEGRAN;
 	tm tm;
Index: libcfa/src/time.hfa
===================================================================
--- libcfa/src/time.hfa	(revision 1d94116e024097476647a17a8c35da1321fed52d)
+++ libcfa/src/time.hfa	(revision e3fea427569271c0c15fd2ca6d3296f213856ead)
@@ -10,6 +10,6 @@
 // Created On       : Wed Mar 14 23:18:57 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan  6 12:50:16 2020
-// Update Count     : 653
+// Last Modified On : Tue Feb  4 08:24:32 2020
+// Update Count     : 654
 //
 
@@ -191,5 +191,5 @@
 } // dmy
 
-size_t strftime( char * buf, size_t size, const char * fmt, Time time );
+size_t strftime( char buf[], size_t size, const char fmt[], Time time );
 
 //------------------------- timeval (cont) -------------------------