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_