Index: libcfa/src/collections/string.cfa
===================================================================
--- libcfa/src/collections/string.cfa	(revision 2f1656963c856b0273be7b573bf11a9e411e68a4)
+++ libcfa/src/collections/string.cfa	(revision bc547d37653baaa8e7fac63a33cc9fe1fd2a3b0f)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri May  8 07:41:00 2026
-// Update Count     : 409
+// Last Modified On : Fri May  8 08:38:51 2026
+// Update Count     : 413
 //
 
@@ -57,10 +57,10 @@
 }
 
-void ?{}( string & s, const char * cs ) {
+void ?{}( string & s, const char cs[] ) {
 	(s.inner) { malloc() };
 	?{}( *s.inner, cs );
 }
 
-void ?{}( string & s, const char * cs , size_t size ) {
+void ?{}( string & s, const char cs[] , size_t size ) {
 	(s.inner) { malloc() };
 	?{}( *s.inner, cs, size );
@@ -128,5 +128,5 @@
 }
 
-string & ?=?( string & s, const char * rhs ) {
+string & ?=?( string & s, const char rhs[] ) {
 	(*s.inner) = rhs;
 	return s;
@@ -138,5 +138,5 @@
 }
 
-string & assign( string & s, const char * rhs, size_t n ) {
+string & assign( string & s, const char rhs[], size_t n ) {
 	assign( *s.inner, rhs, n );
 	return s;
@@ -177,5 +177,5 @@
 
 // safe conversion from string to char *
-char * strncpy( char * dst, string & src, size_t n ) {
+char * strncpy( char dst[], string & src, size_t n ) {
 	size_t l = min( n - 1, len( src ) );				// ensure null terminated
 	for ( i; l ) dst[i] = src[i];
@@ -273,9 +273,9 @@
 }
 
-void ?+=?( string & s, const char * cs ) {
+void ?+=?( string & s, const char cs[] ) {
 	(*s.inner) += cs;
 }
 
-void append( string & s, const char * buffer, size_t bsize ) {
+void append( string & s, const char buffer[], size_t bsize ) {
 	append( (*s.inner), buffer, bsize );
 }
@@ -299,5 +299,5 @@
 }
 
-string ?+?( const char * cs,  char c ) {
+string ?+?( const char cs[],  char c ) {
 	string ret = cs;
 	ret += c;
@@ -305,5 +305,5 @@
 }
 
-string ?+?( char c, const char * cs ) {
+string ?+?( char c, const char cs[] ) {
 	string ret = c;
 	ret += cs;
@@ -311,5 +311,5 @@
 }
 
-string ?+?( const char * cs1, const char * cs2 ) {
+string ?+?( const char cs1[], const char cs2[] ) {
 	string ret = cs1;
 	ret += cs2;
@@ -317,5 +317,5 @@
 }
 
-string ?+?( const char * cs, string s ) {
+string ?+?( const char cs[], string s ) {
 	string ret = cs;
 	ret += s;
@@ -323,5 +323,5 @@
 }
 
-string ?+?( string s, const char * cs ) {
+string ?+?( string s, const char cs[] ) {
 	string ret = s;
 	ret += cs;
@@ -354,5 +354,5 @@
 }
 
-string ?*?( const char * cs, strmul_factor_t factor ) {
+string ?*?( const char cs[], strmul_factor_t factor ) {
 	string ret = cs;
 	ret *= factor;
@@ -384,5 +384,5 @@
 }
 
-int strncmp( const string & s, const char * cs, size_t maxlen ) {
+int strncmp( const string & s, const char cs[], size_t maxlen ) {
 	size_t cslen = len( cs );
 	if ( maxlen > len( s ) || maxlen > cslen ) {
@@ -392,10 +392,10 @@
 }
 
-int strncmp( const char * s, const string & cs, size_t maxlen ) {
-	size_t slen = len( s );
-	if ( maxlen > slen || maxlen > len( cs ) ) {
-		abort( STRNCPY_FMT, maxlen, slen, len( cs ) );
+int strncmp( const char cs[], const string & s, size_t maxlen ) {
+	size_t slen = len( cs );
+	if ( maxlen > slen || maxlen > len( s ) ) {
+		abort( STRNCPY_FMT, maxlen, slen, len( s ) );
 	} // if
-	return strcmp$( s, maxlen, cs.inner->Handle.s, maxlen );
+	return strcmp$( cs, maxlen, s.inner->Handle.s, maxlen );
 }
 
@@ -425,9 +425,9 @@
 }
 
-size_t find( const string & s, const char * key ) {
+size_t find( const string & s, const char key[] ) {
 	return find( *s.inner, key );
 }
 
-size_t find( const string & s, const char * key, size_t keysize ) {
+size_t find( const string & s, const char key[], size_t keysize ) {
 	return find( *s.inner, key, keysize );
 }
@@ -437,9 +437,9 @@
 }
 
-size_t find( const string & s, size_t start, const char * key ) {
+size_t find( const string & s, size_t start, const char key[] ) {
 	return findFrom( *s.inner, start, key );
 }
 
-size_t find( const string & s, size_t start, const char * key, size_t keysize ) {
+size_t find( const string & s, size_t start, const char key[], size_t keysize ) {
 	return findFrom( *s.inner, start, key, keysize );
 }
@@ -449,9 +449,9 @@
 // }
 
-// bool includes( const string & s, const char * search ) {
+// bool includes( const string & s, const char search[] ) {
 // 	return includes( *s.inner, search );
 // }
 
-// bool includes( const string & s, const char * search, size_t searchsize ) {
+// bool includes( const string & s, const char search[], size_t searchsize ) {
 // 	return includes( *s.inner, search, searchsize );
 // }
@@ -461,9 +461,9 @@
 }
 
-bool startsWith( const string & s, const char * prefix ) {
+bool startsWith( const string & s, const char prefix[] ) {
 	return startsWith( *s.inner, prefix );
 }
 
-bool startsWith( const string & s, const char * prefix, size_t prefixsize ) {
+bool startsWith( const string & s, const char prefix[], size_t prefixsize ) {
 	return startsWith( *s.inner, prefix, prefixsize );
 }
@@ -473,9 +473,9 @@
 }
 
-bool endsWith( const string & s, const char * suffix ) {
+bool endsWith( const string & s, const char suffix[] ) {
 	return endsWith( *s.inner, suffix );
 }
 
-bool endsWith( const string & s, const char * suffix, size_t suffixsize ) {
+bool endsWith( const string & s, const char suffix[], size_t suffixsize ) {
 	return endsWith( *s.inner, suffix, suffixsize );
 }
@@ -490,10 +490,10 @@
 }
 
-void ?{}( charclass & s, const char * chars ) {
+void ?{}( charclass & s, const char chars[] ) {
 	(s.inner) { malloc() };
 	?{}( *s.inner, chars );
 }
 
-void ?{}( charclass & s, const char * chars, size_t charssize ) {
+void ?{}( charclass & s, const char chars[], size_t charssize ) {
 	(s.inner) { malloc() };
 	?{}( *s.inner, chars, charssize );
Index: libcfa/src/collections/string.hfa
===================================================================
--- libcfa/src/collections/string.hfa	(revision 2f1656963c856b0273be7b573bf11a9e411e68a4)
+++ libcfa/src/collections/string.hfa	(revision bc547d37653baaa8e7fac63a33cc9fe1fd2a3b0f)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri May  8 07:40:57 2026
-// Update Count     : 353
+// Last Modified On : Fri May  8 18:07:38 2026
+// Update Count     : 367
 //
 
@@ -33,6 +33,6 @@
 PBOOST void ?{}( string & s, string s2 );
 void ?{}( string & s, char );
-void ?{}( string & s, const char * cs );				// copy from string literal (NULL-terminated)
-void ?{}( string & s, const char * cs, size_t size );	// copy specific length from buffer
+void ?{}( string & s, const char cs[] );				// copy from string literal (NULL-terminated)
+void ?{}( string & s, const char cs[], size_t size );	// copy specific length from buffer
 void ?{}( string & s, size_t rhs );
 void ?{}( string & s, ssize_t rhs );
@@ -44,7 +44,7 @@
 PBOOST string & ?=?( string & s, string rhs );
 string & ?=?( string & s, char rhs );					// copy from 'l'
-string & ?=?( string & s, const char * rhs );			// copy from "literal"
+string & ?=?( string & s, const char rhs[] );			// copy from "literal"
 string & assign( string & s, const string & rhs, size_t n );
-string & assign( string & s, const char * rhs, size_t n );
+string & assign( string & s, const char rhs[], size_t n );
 string & ?=?( string & s, size_t rhs );
 string & ?=?( string & s, ssize_t rhs );
@@ -56,5 +56,5 @@
 // Conversion
 static inline string tostr( char c ) { string s = c; return s; }
-static inline string tostr( const char * cs ) { string s = cs; return s; }
+static inline string tostr( const char cs[] ) { string s = cs; return s; }
 static inline string tostr( size_t v ) { string s = v; return s; }
 static inline string tostr( ssize_t v ) { string s = v; return s; }
@@ -64,9 +64,9 @@
 
 // C compatibility
-static inline string & strcpy( string & s, const char * cs ) { s = cs; return s; }
-static inline string & strncpy( string & s, const char * cs, size_t n ) { assign( s, cs, n ); return s; }
+static inline string & strcpy( string & s, const char cs[] ) { s = cs; return s; }
+static inline string & strncpy( string & s, const char cs[], size_t n ) { assign( s, cs, n ); return s; }
 static inline string & strcpy( string & s1, const string & s2 ) { s1 = s2; return s1; }
 static inline string & strncpy( string & s, const string & cs, size_t n ) { assign( s, cs, n ); return s; }
-char * strncpy( char * dst, string & src, size_t n );
+char * strncpy( char dst[], string & src, size_t n );
 char * ?=?( char *& dst, string & src );
 void ?{}( char *& dst, string & src );
@@ -81,5 +81,5 @@
 // Getters
 static inline size_t len( const string & s ) { return len( *s.inner ); }
-static inline size_t len( const char * cs ) { return strlen( cs ); };
+static inline size_t len( const char cs[] ) { return strlen( cs ); };
 static inline size_t strlen( const string & s ) { return len( s ); }
 size_t strnlen( const string & s, size_t maxlen );
@@ -119,4 +119,6 @@
 	inline _Istream_str_base;
 }; // _Istream_Swidth
+
+// Restrict nesting of input manipulators to those combinations that make sense.
 
 struct _Istream_Squote {
@@ -166,21 +168,21 @@
 PBOOST void ?+=?( string & s, string );
 void append( string & s, const string & s2, size_t maxlen );
-void ?+=?( string & s, const char * cs );
-void append( string & s, const char * buffer, size_t bsize );
+void ?+=?( string & s, const char cs[] );
+void append( string & s, const char buffer[], size_t bsize );
 
 string ?+?( string s, char c );
 string ?+?( char c, string s );
 PBOOST string ?+?( string s, string s2 );
-string ?+?( const char * cs, char c );					// not backwards compatible
-string ?+?( char c, const char * cs );
-string ?+?( const char * cs1 , const char * cs2 );
-string ?+?( const char * cs , string s );
-string ?+?( string s, const char * cs  );
+string ?+?( const char cs[], char c );					// not backwards compatible
+string ?+?( char c, const char cs[] );
+string ?+?( const char cs1[] , const char cs2[] );
+string ?+?( const char cs[] , string s );
+string ?+?( string s, const char cs[]  );
 string ?+?( char, char );								// not being called 8-(
 
 static inline string & strcat( string & s1, const string & s2 ) { s1 += s2; return s1; }
-static inline string & strcat( string & s, const char * cs  ) { s += cs; return s; }
+static inline string & strcat( string & s, const char cs[]  ) { s += cs; return s; }
 static inline string & strncat( string & s1, const string & s2, size_t maxlen ) { append( s1, s2, maxlen ); return s1; }
-static inline string & strncat( string & s, const char * buffer, size_t bsize ) { append( s, buffer, bsize ); return s; }
+static inline string & strncat( string & s, const char buffer[], size_t bsize ) { append( s, buffer, bsize ); return s; }
 
 // Repetition
@@ -194,8 +196,8 @@
 string ?*?( char c, strmul_factor_t factor );					// not backwards compatible
 PBOOST string ?*?( string s, strmul_factor_t factor );
-string ?*?( const char * cs, strmul_factor_t factor );
+string ?*?( const char cs[], strmul_factor_t factor );
 static inline string ?*?( strmul_factor_t factor, char c ) { return c * factor; }
 PBOOST static inline string ?*?( strmul_factor_t factor, string s ) { return s * factor; }
-static inline string ?*?( strmul_factor_t factor, const char * cs ) { return cs * factor; }
+static inline string ?*?( strmul_factor_t factor, const char cs[] ) { return cs * factor; }
 
 // Character access
@@ -214,46 +216,46 @@
 static inline bool ?<? ( const string & s1, const string & s2 ) { return *s1.inner <  *s2.inner; }
 
-static inline int strcmp( const string & s1, const char * s2 ) { return strcmp( *s1.inner, s2 ); }
-int strncmp( const string & s1, const char * s2, size_t maxlen );
-static inline bool ?==?( const string & s1, const char * s2 ) { return *s1.inner == s2; }
-static inline bool ?!=?( const string & s1, const char * s2 ) { return *s1.inner != s2; }
-static inline bool ?>? ( const string & s1, const char * s2 ) { return *s1.inner >  s2; }
-static inline bool ?>=?( const string & s1, const char * s2 ) { return *s1.inner >= s2; }
-static inline bool ?<=?( const string & s1, const char * s2 ) { return *s1.inner <= s2; }
-static inline bool ?<? ( const string & s1, const char * s2 ) { return *s1.inner <  s2; }
-
-static inline int strcmp( const char * s1, const string & s2 ) { return strcmp( s1, *s2.inner ); }
-int strncmp( const char * s1, const string & s2, size_t maxlen );
-static inline bool ?==?( const char * s1, const string & s2 ) { return s1 == *s2.inner; }
-static inline bool ?!=?( const char * s1, const string & s2 ) { return s1 != *s2.inner; }
-static inline bool ?>? ( const char * s1, const string & s2 ) { return s1 >  *s2.inner; }
-static inline bool ?>=?( const char * s1, const string & s2 ) { return s1 >= *s2.inner; }
-static inline bool ?<=?( const char * s1, const string & s2 ) { return s1 <= *s2.inner; }
-static inline bool ?<? ( const char * s1, const string & s2 ) { return s1 <  *s2.inner; }
+static inline int strcmp( const string & s, const char cs[] ) { return strcmp( *s.inner, cs ); }
+int strncmp( const string & s1, const char cs[], size_t maxlen );
+static inline bool ?==?( const string & s, const char cs[] ) { return *s.inner == cs; }
+static inline bool ?!=?( const string & s, const char cs[] ) { return *s.inner != cs; }
+static inline bool ?>? ( const string & s, const char cs[] ) { return *s.inner >  cs; }
+static inline bool ?>=?( const string & s, const char cs[] ) { return *s.inner >= cs; }
+static inline bool ?<=?( const string & s, const char cs[] ) { return *s.inner <= cs; }
+static inline bool ?<? ( const string & s, const char cs[] ) { return *s.inner <  cs; }
+
+static inline int strcmp( const char cs[], const string & s ) { return strcmp( cs, *s.inner ); }
+int strncmp( const char cs[], const string & s, size_t maxlen );
+static inline bool ?==?( const char cs[], const string & s ) { return cs == *s.inner; }
+static inline bool ?!=?( const char cs[], const string & s ) { return cs != *s.inner; }
+static inline bool ?>? ( const char cs[], const string & s ) { return cs >  *s.inner; }
+static inline bool ?>=?( const char cs[], const string & s ) { return cs >= *s.inner; }
+static inline bool ?<=?( const char cs[], const string & s ) { return cs <= *s.inner; }
+static inline bool ?<? ( const char cs[], const string & s ) { return cs <  *s.inner; }
 
 // String search
 
 size_t find( const string & s, char key );
-size_t find( const string & s, const char * key );
+size_t find( const string & s, const char key[] );
 size_t find( const string & s, const string & key );
-size_t find( const string & s, const char * key, size_t keysize );
+size_t find( const string & s, const char key[], size_t keysize );
 
 size_t find( const string & s, size_t start, char key );
 size_t find( const string & s, size_t start, const string & key );
-size_t find( const string & s, size_t start, const char * key );
-size_t find( const string & s, size_t start, const char * key, size_t keysize );
+size_t find( const string & s, size_t start, const char key[] );
+size_t find( const string & s, size_t start, const char key[], size_t keysize );
 
 static inline bool includes( const string & s, char key ) { return find( s, key ) < len( s ); }
-static inline bool includes( const string & s, const char * key ) { return find( s, key ) < len( s ); }
+static inline bool includes( const string & s, const char key[] ) { return find( s, key ) < len( s ); }
 static inline bool includes( const string & s, const string & key ) { return find( s, key ) < len( s ); }
-static inline bool includes( const string & s, const char * key, size_t keysize ){ return find( s, key, keysize ) < len( s ); }
+static inline bool includes( const string & s, const char key[], size_t keysize ){ return find( s, key, keysize ) < len( s ); }
 
 bool startsWith( const string & s, const string & prefix );
-bool startsWith( const string & s, const char * prefix );
-bool startsWith( const string & s, const char * prefix, size_t prefixsize );
+bool startsWith( const string & s, const char prefix[] );
+bool startsWith( const string & s, const char prefix[], size_t prefixsize );
 
 bool endsWith( const string & s, const string & suffix );
-bool endsWith( const string & s, const char * suffix );
-bool endsWith( const string & s, const char * suffix, size_t suffixsize );
+bool endsWith( const string & s, const char suffix[] );
+bool endsWith( const string & s, const char suffix[], size_t suffixsize );
 
 // Slicing
@@ -264,6 +266,6 @@
 static inline string ?()( string & s, char m ) { return s( find( s, m ), 1 )`share; }
 static inline string ?()( const string & s, char m ) { string & w = (string &)s; return w( find( s, m ), 1 )`share; } // FIX ME
-static inline string ?()( string & s, const char * m ) { return s( find( s, m ), len( m ) )`share; }
-static inline string ?()( const string & s, const char * m ) { string & w = (string &)s; return w( find( s, m ), len( m ) )`share; } // FIX ME
+static inline string ?()( string & s, const char m[] ) { return s( find( s, m ), len( m ) )`share; }
+static inline string ?()( const string & s, const char m[] ) { string & w = (string &)s; return w( find( s, m ), len( m ) )`share; } // FIX ME
 static inline string ?()( string & s, const string & m ) { return s( find( s, m ), len( m ) )`share; }
 static inline string ?()( const string & s, const string & m ) { string & w = (string &)s; return w( find( s, m ), len( m ) )`share; } // FIX ME
@@ -278,67 +280,67 @@
 
 void ?{}( charclass &, const string & chars );
-void ?{}( charclass &, const char * chars );
-void ?{}( charclass &, const char * chars, size_t charssize );
+void ?{}( charclass &, const char chars[] );
+void ?{}( charclass &, const char chars[], size_t charssize );
 void ^?{}( charclass & );
 
 size_t include( const string & s, const charclass & mask );
-static inline size_t include( const string & s, const char * mask ) { return include( s, (charclass){ mask } ); }
+static inline size_t include( const string & s, const char mask[] ) { return include( s, (charclass){ mask } ); }
 static inline size_t include( const string & s, const string & mask ) { return include( s, (charclass){ mask } ); }
-static inline size_t include( const char * cs, const charclass & mask ) { return include( (string){ cs }, mask ); }
-static inline size_t include( const char * cs, const char * mask ) { return include( (string){ cs }, (charclass){ mask } ); }
-static inline size_t include( const char * cs, const string & mask ) { return include( (string){ cs }, (charclass){ mask } ); }
+static inline size_t include( const char cs[], const charclass & mask ) { return include( (string){ cs }, mask ); }
+static inline size_t include( const char cs[], const char mask[] ) { return include( (string){ cs }, (charclass){ mask } ); }
+static inline size_t include( const char cs[], const string & mask ) { return include( (string){ cs }, (charclass){ mask } ); }
 
 static inline string include( const string & s, const charclass & mask ) { return s( 0, include( s, mask ) ); }
-static inline string include( const string & s, const char * mask ) { return s( 0, include( s, (charclass){ mask } ) ); }
+static inline string include( const string & s, const char mask[] ) { return s( 0, include( s, (charclass){ mask } ) ); }
 static inline string include( const string & s, const string & mask ) { return s( 0, include( s, (charclass){ mask } ) ); }
-static inline string include( const char * cs, const charclass & mask ) { const string s = cs; return s( 0, include( s, mask ) ); }
-static inline string include( const char * cs, const char * mask ) { const string s = cs; return s( 0, include( s, (charclass){ mask } ) ); }
-static inline string include( const char * cs, const string & mask ) { const string s = cs; return s( 0, include( s, (charclass){ mask } ) ); }
+static inline string include( const char cs[], const charclass & mask ) { const string s = cs; return s( 0, include( s, mask ) ); }
+static inline string include( const char cs[], const char mask[] ) { const string s = cs; return s( 0, include( s, (charclass){ mask } ) ); }
+static inline string include( const char cs[], const string & mask ) { const string s = cs; return s( 0, include( s, (charclass){ mask } ) ); }
 
 size_t exclude( const string & s, const charclass & mask );
-static inline size_t exclude( const string & s, const char * mask ) { return exclude( s, (charclass){ mask } ); }
+static inline size_t exclude( const string & s, const char mask[] ) { return exclude( s, (charclass){ mask } ); }
 static inline size_t exclude( const string & s, const string & mask ) { return exclude( s, (charclass){ mask } ); }
-static inline size_t exclude( const char * cs, const charclass & mask ) { return exclude( (string){ cs }, mask ); }
-static inline size_t exclude( const char * cs, const string & mask ) { return exclude( (string){ cs }, (charclass){ mask } ); }
-static inline size_t exclude( const char * cs, const char * mask ) { return exclude( (string){ cs }, (charclass){ mask } ); }
+static inline size_t exclude( const char cs[], const charclass & mask ) { return exclude( (string){ cs }, mask ); }
+static inline size_t exclude( const char cs[], const string & mask ) { return exclude( (string){ cs }, (charclass){ mask } ); }
+static inline size_t exclude( const char cs[], const char mask[] ) { return exclude( (string){ cs }, (charclass){ mask } ); }
 
 static inline string exclude( const string & s, const charclass & mask ) { return s( 0, exclude( s, mask ) ); }
-static inline string exclude( const string & s, const char * mask ) { return s( 0, exclude( s, (charclass){ mask } ) ); }
+static inline string exclude( const string & s, const char mask[] ) { return s( 0, exclude( s, (charclass){ mask } ) ); }
 static inline string exclude( const string & s, const string & mask ) { return s( 0, exclude( s, (charclass){ mask } ) ); }
-static inline string exclude( const char * cs, const charclass & mask ) { const string s = cs; return s( 0, exclude( s, mask ) ); }
-static inline string exclude( const char * cs, const string & mask ) { const string s = cs; return s( 0, exclude( s, (charclass){ mask } ) ); }
-static inline string exclude( const char * cs, const char * mask ) { const string s = cs; return s( 0, exclude( s, (charclass){ mask } ) ); }
+static inline string exclude( const char cs[], const charclass & mask ) { const string s = cs; return s( 0, exclude( s, mask ) ); }
+static inline string exclude( const char cs[], const string & mask ) { const string s = cs; return s( 0, exclude( s, (charclass){ mask } ) ); }
+static inline string exclude( const char cs[], const char mask[] ) { const string s = cs; return s( 0, exclude( s, (charclass){ mask } ) ); }
 
 size_t include( const string & s, int (* f)( int ) );	// for C character-class functions, e.g., isdigit
-static inline size_t include( const char * cs, int (* f)( int ) ) { return include( (string){ cs }, f ); }
+static inline size_t include( const char cs[], int (* f)( int ) ) { return include( (string){ cs }, f ); }
 static inline string include( const string & s, int (* f)( int ) ) { return s( 0, include( s, f ) ); }
-static inline string include( const char * cs, int (* f)( int ) ) { const string s = cs; return s( 0, include( s, f ) ); }
+static inline string include( const char cs[], int (* f)( int ) ) { const string s = cs; return s( 0, include( s, f ) ); }
 
 static inline size_t include( const string & s, bool (* f)( char ) ) { return include( s, (int (*)( int ))f ); }
-static inline size_t include( const char * cs, bool (* f)( char ) ) { return include( (string){ cs }, f ); }
+static inline size_t include( const char cs[], bool (* f)( char ) ) { return include( (string){ cs }, f ); }
 static inline string include( const string & s, bool (* f)( char ) ) { return s( 0, include( s, f ) ); }
-static inline string include( const char * cs, bool (* f)( char ) ) { const string s = cs; return s( 0, include( s, f ) ); }
+static inline string include( const char cs[], bool (* f)( char ) ) { const string s = cs; return s( 0, include( s, f ) ); }
 
 size_t exclude( const string & s, int (* f)( int ) );	// for C character-class functions, e.g., isdigit
-static inline size_t exclude( const char * cs, int (* f)( int ) ) { return exclude( (string){ cs }, f ); }
+static inline size_t exclude( const char cs[], int (* f)( int ) ) { return exclude( (string){ cs }, f ); }
 static inline string exclude( const string & s, int (* f)( int ) ) { return s( 0, exclude( s, f ) ); }
-static inline string exclude( const char * cs, int (* f)( int ) ) { const string s = cs; return s( 0, exclude( s, f ) ); }
+static inline string exclude( const char cs[], int (* f)( int ) ) { const string s = cs; return s( 0, exclude( s, f ) ); }
 
 static inline size_t exclude( const string & s, bool (* f)( char ) ) { return exclude( s, (int (*)( int ))f ); }
-static inline size_t exclude( const char * cs, bool (* f)( char ) ) { return exclude( (string){ cs }, f ); }
+static inline size_t exclude( const char cs[], bool (* f)( char ) ) { return exclude( (string){ cs }, f ); }
 static inline string exclude( const string & s, bool (* f)( char ) ) { return s( 0, exclude( s, f ) ); }
-static inline string exclude( const char * cs, bool (* f)( char ) ) { const string s = cs; return s( 0, exclude( s, f ) ); }
+static inline string exclude( const char cs[], bool (* f)( char ) ) { const string s = cs; return s( 0, exclude( s, f ) ); }
 
 string replace( const string & s, const string & from, const string & to );
-static inline string replace( const char * cs, const char * from, const char * to ) { return replace( (string){ cs }, (string){ from }, (string){ to } ); }
-static inline string replace( const string & s, const char * from, const char * to ) { return replace( s, (string){ from }, (string){ to } ); }
-static inline string replace( const string & s, const char * from, const string & to ) { return replace( s, (string){ from }, to ); }
-static inline string replace( const string & s, string & from, const char * to ) { return replace( s, from, (string){ to } ); }
+static inline string replace( const char cs[], const char from[], const char to[] ) { return replace( (string){ cs }, (string){ from }, (string){ to } ); }
+static inline string replace( const string & s, const char from[], const char to[] ) { return replace( s, (string){ from }, (string){ to } ); }
+static inline string replace( const string & s, const char from[], const string & to ) { return replace( s, (string){ from }, to ); }
+static inline string replace( const string & s, string & from, const char to[] ) { return replace( s, from, (string){ to } ); }
 
 string translate( const string & s, int (* f)( int ) );	// for C character-class functions, e.g., isdigit
-static inline string translate( const char * cs, int (* f)( int ) ) { return translate( (string){ cs }, f ); }
+static inline string translate( const char cs[], int (* f)( int ) ) { return translate( (string){ cs }, f ); }
 
 static inline string translate( const string & s, bool (* f)( char ) ) { return translate( s, (int (*)( int ))f ); }
-static inline string translate( const char * cs, bool (* f)( char ) ) { return translate( (string){ cs }, f ); }
+static inline string translate( const char cs[], bool (* f)( char ) ) { return translate( (string){ cs }, f ); }
 
 #ifndef _COMPILING_STRING_CFA_