Index: libcfa/src/collections/string.cfa
===================================================================
--- libcfa/src/collections/string.cfa	(revision e1358c0ea59c560c010e5261b3e1fe2ac3ad8a2c)
+++ libcfa/src/collections/string.cfa	(revision 4223317e3e759f006fdf485a8ab0ebb78ef3c267)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 14 15:41:33 2025
-// Update Count     : 275
+// Last Modified On : Tue Apr  1 09:17:34 2025
+// Update Count     : 288
 //
 
@@ -31,71 +31,71 @@
 // private (not in header)
 static void ?{}( string & s, string_res & src, size_t start, size_t len ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, src, SHARE_EDITS, start, len );
+	(s.inner) { malloc() };
+	?{}( *s.inner, src, SHARE_EDITS, start, len );
 }
 
 void ?{}( string & s ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner );
+	(s.inner) { malloc() };
+	?{}( *s.inner );
 }
 
 void ?{}( string & s, const string & c ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, *c.inner, COPY_VALUE );
+	(s.inner) { malloc() };
+	?{}( *s.inner, *c.inner, COPY_VALUE );
 }
 
 void ?{}( string & s, const string & s2, size_t maxlen ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, *s2.inner, COPY_VALUE, maxlen );
+	(s.inner) { malloc() };
+	?{}( *s.inner, *s2.inner, COPY_VALUE, maxlen );
 }
 
 
 void ?{}( string & s, string & c ) {
-    ?{}( s, (const string &) c );
+	?{}( s, (const string &) c );
 }
 
 void ?{}( string & s, const char c ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, c );
+	(s.inner) { malloc() };
+	?{}( *s.inner, c );
 }
 
 void ?{}( string & s, const char * c ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, c );
+	(s.inner) { malloc() };
+	?{}( *s.inner, c );
 }
 
 void ?{}( string & s, const char * c, size_t size ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, c, size );
+	(s.inner) { malloc() };
+	?{}( *s.inner, c, size );
 }
 
 void ?{}( string & s, ssize_t rhs ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, rhs );
+	(s.inner) { malloc() };
+	?{}( *s.inner, rhs );
 }
 
 void ?{}( string & s, size_t rhs ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, rhs );
+	(s.inner) { malloc() };
+	?{}( *s.inner, rhs );
 }
 
 void ?{}( string & s, double rhs ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, rhs );
+	(s.inner) { malloc() };
+	?{}( *s.inner, rhs );
 }
 
 void ?{}( string & s, long double rhs ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, rhs );
+	(s.inner) { malloc() };
+	?{}( *s.inner, rhs );
 }
 
 void ?{}( string & s, double _Complex rhs ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, rhs );
+	(s.inner) { malloc() };
+	?{}( *s.inner, rhs );
 }
 
 void ?{}( string & s, long double _Complex rhs ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, rhs );
+	(s.inner) { malloc() };
+	?{}( *s.inner, rhs );
 }
 
@@ -131,7 +131,7 @@
 
 void ^?{}( string & s ) {
-    ^(*s.inner){};
-    free( s.inner );
-    s.inner = 0p;
+	^(*s.inner){};
+	free( s.inner );
+	s.inner = 0p;
 }
 
@@ -140,10 +140,10 @@
 
 string_Share ?`share( string & s ) {
-    string_Share ret = { &s };
-    return ret;
+	string_Share ret = { &s };
+	return ret;
 }
 
 void ?{}( string & s, string_Share src ) {
-    ?{}( s, *src.s->inner, 0, src.s->inner->Handle.lnth );
+	?{}( s, *src.s->inner, 0, src.s->inner->Handle.lnth );
 }
 
@@ -152,61 +152,61 @@
 
 string & ?=?( string & s, const string & c ) {
-    (*s.inner) = (*c.inner);
-    return s;
+	(*s.inner) = (*c.inner);
+	return s;
 }
 
 string & ?=?( string & s, string & c ) {
-    (*s.inner) = (*c.inner);
-    return s;
+	(*s.inner) = (*c.inner);
+	return s;
 }
 
 string & ?=?( string & s, const char * val ) {
-    (*s.inner) = val;
-    return s;
+	(*s.inner) = val;
+	return s;
 }
 
 string & ?=?( string & s, char val ) {
-    (*s.inner) = val;
-    return s;
+	(*s.inner) = val;
+	return s;
 }
 
 string & assign( string & s, const string & c, size_t n ) {
-    assign( *s.inner, *c.inner, n );
-    return s;
+	assign( *s.inner, *c.inner, n );
+	return s;
 }
 
 string & assign( string & s, const char * c, size_t n ) {
-    assign( *s.inner, c, n );
-    return s;
+	assign( *s.inner, c, n );
+	return s;
 }
 
 string & ?=?( string & s, ssize_t rhs ) {
-    (*s.inner) = rhs;
-    return s;
+	(*s.inner) = rhs;
+	return s;
 }
 
 string & ?=?( string & s, size_t rhs ) {
-    (*s.inner) = rhs;
-    return s;
+	(*s.inner) = rhs;
+	return s;
 }
 
 string & ?=?( string & s, double rhs ) {
-    (*s.inner) = rhs;
-    return s;
+	(*s.inner) = rhs;
+	return s;
 }
 
 string & ?=?( string & s, long double rhs ) {
-    (*s.inner) = rhs;
-    return s;
+	(*s.inner) = rhs;
+	return s;
 }
 
 string & ?=?( string & s, double _Complex rhs ) {
-    (*s.inner) = rhs;
-    return s;
+	(*s.inner) = rhs;
+	return s;
 }
 
 string & ?=?( string & s, long double _Complex rhs ) {
-    (*s.inner) = rhs;
-    return s;
+	(*s.inner) = rhs;
+	return s;
 }
 
@@ -215,9 +215,9 @@
 
 ofstream & ?|?( ofstream & out, const string & s ) {
-    return out | (*s.inner); // print internal string_res
+	return out | (*s.inner); // print internal string_res
 }
 
 void ?|?( ofstream & out, const string & s ) {
-    (ofstream &)(out | (*s.inner)); ends( out );
+	(ofstream &)(out | (*s.inner)); ends( out );
 }
 
@@ -236,10 +236,10 @@
 
 ifstream & ?|?( ifstream & in, string & s ) {
-    return in | (*s.inner); // read to internal string_res
+	return in | (*s.inner); // read to internal string_res
 }
 
 ifstream & ?|?( ifstream & is, _Istream_Squoted f ) {
 	_Istream_Rquoted f2 = { { f.sstr.s.inner, (_Istream_str_base)f.sstr } };
-    return is | f2;
+	return is | f2;
 } // ?|?
 
@@ -247,5 +247,5 @@
 // 	_Istream_Rstr f2 = {f.sstr.s.inner, (_Istream_str_base)f.sstr};
  	_Istream_Rstr f2 = {f.s.inner, (_Istream_str_base)f};
-    return is | f2;
+	return is | f2;
 } // ?|?
 
@@ -253,12 +253,17 @@
 // Slicing
 
-string ?()( string & s, size_t start, size_t len ) {
-    string ret = { *s.inner, start, len };
-    return ret`share;
-}
-
-string ?()( string & s, size_t start ) {
-    string ret = { *s.inner, start, size( s ) - start };
-    return ret`share;
+string ?()( string & s, ssize_t start, ssize_t len ) {
+	if ( start < 0 ) { start += s`len; }
+	if ( len < 0 ) { len = -len; start -= len; }
+	if ( start > s`len ) return (string){ "" };
+	if ( start + len > s`len ) len = s`len - start;
+	string ret = { *s.inner, start, len };
+	return ret`share;
+}
+
+string ?()( string & s, ssize_t start ) {
+	if ( start < 0 ) { start += s`len; }
+	string ret = { *s.inner, start, size( s ) - start };
+	return ret`share;
 }
 
@@ -295,5 +300,5 @@
 
 size_t size( const string & s ) {
-    return size( *s.inner );
+	return size( *s.inner );
 }
 
@@ -302,69 +307,69 @@
 
 void ?+=?( string & s, char c ) {
-    (*s.inner) += c;
+	(*s.inner) += c;
 }
 
 void ?+=?( string & s, const string & s2 ) {
-    (*s.inner) += (*s2.inner);
+	(*s.inner) += (*s2.inner);
 }
 
 void append( string & s, const string & s2, size_t maxlen ) {
-    append( (*s.inner), (*s2.inner), maxlen );
+	append( (*s.inner), (*s2.inner), maxlen );
 }
 
 void ?+=?( string & s, const char * c ) {
-    (*s.inner) += c;
+	(*s.inner) += c;
 }
 
 void append( string & s, const char * buffer, size_t bsize ) {
-    append( (*s.inner), buffer, bsize );
+	append( (*s.inner), buffer, bsize );
 }
 
 string ?+?( const string & s, char c ) {
-    string ret = s;
-    ret += c;
-    return ret;
+	string ret = s;
+	ret += c;
+	return ret;
 }
 
 string ?+?( char c, const string & s ) {
-    string ret = s;
-    ret += c;
-    return ret;
+	string ret = s;
+	ret += c;
+	return ret;
 }
 
 string ?+?( const string & s, const string & s2 ) {
-    string ret = s;
-    ret += s2;
-    return ret;
+	string ret = s;
+	ret += s2;
+	return ret;
 }
 
 string ?+?( const char * s,  char c ) {
-    string ret = s;
-    ret += c;
-    return ret;
+	string ret = s;
+	ret += c;
+	return ret;
 }
 
 string ?+?( char c, const char * s ) {
-    string ret = c;
-    ret += s;
-    return ret;
+	string ret = c;
+	ret += s;
+	return ret;
 }
 
 string ?+?( const char * s1, const char * s2 ) {
-    string ret = s1;
-    ret += s2;
-    return ret;
+	string ret = s1;
+	ret += s2;
+	return ret;
 }
 
 string ?+?( const char * s1, string & s2 ) {
-    string ret = s1;
-    ret += s2;
-    return ret;
+	string ret = s1;
+	ret += s2;
+	return ret;
 }
 
 string ?+?( const string & s, const char * c ) {
-    string ret = s;
-    ret += c;
-    return ret;
+	string ret = s;
+	ret += c;
+	return ret;
 }
 
@@ -373,23 +378,23 @@
 
 void ?*=?( string & s, size_t factor ) {
-    (*s.inner) *= factor;
+	(*s.inner) *= factor;
 }
 
 string ?*?( const string & s, size_t factor ) {
-    string ret = s;
-    ret *= factor;
-    return ret;
+	string ret = s;
+	ret *= factor;
+	return ret;
 }
 
 string ?*?( char c, size_t factor ) {
-    string ret = c;
-    ret *= factor;
-    return ret;
+	string ret = c;
+	ret *= factor;
+	return ret;
 }
 
 string ?*?( const char * s, size_t factor ) {
-    string ret = s;
-    ret *= factor;
-    return ret;
+	string ret = s;
+	ret *= factor;
+	return ret;
 }
 
@@ -398,10 +403,10 @@
 
 char ?[?]( const string & s, size_t index ) {
-    return (*s.inner)[index];
+	return (*s.inner)[index];
 }
 
 string ?[?]( string & s, size_t index ) {
-    string ret = { *s.inner, index, 1 };
-    return ret`share;
+	string ret = { *s.inner, index, 1 };
+	return ret`share;
 }
 
@@ -410,73 +415,73 @@
 
 bool contains( const string & s, char ch ) {
-    return contains( *s.inner, ch );
+	return contains( *s.inner, ch );
 }
 
 int find( const string & s, char search ) {
-    return find( *s.inner, search );
+	return find( *s.inner, search );
 }
 
 int find( const string & s, const string & search ) {
-    return find( *s.inner, *search.inner );
+	return find( *s.inner, *search.inner );
 }
 
 int find( const string & s, const char * search ) {
-    return find( *s.inner, search );
+	return find( *s.inner, search );
 }
 
 int find( const string & s, const char * search, size_t searchsize ) {
-    return find( *s.inner, search, searchsize );
-}
-
-int findFrom( const string & s, size_t fromPos, char search ) {
-    return findFrom( *s.inner, fromPos, search );
-}
-
-int findFrom( const string & s, size_t fromPos, const string & search ) {
-    return findFrom( *s.inner, fromPos, *search.inner );
-}
-
-int findFrom( const string & s, size_t fromPos, const char * search ) {
-    return findFrom( *s.inner, fromPos, search );
-}
-
-int findFrom( const string & s, size_t fromPos, const char * search, size_t searchsize ) {
-    return findFrom( *s.inner, fromPos, search, searchsize );
+	return find( *s.inner, search, searchsize );
+}
+
+int find( const string & s, size_t fromPos, char search ) {
+	return findFrom( *s.inner, fromPos, search );
+}
+
+int find( const string & s, size_t fromPos, const string & search ) {
+	return findFrom( *s.inner, fromPos, *search.inner );
+}
+
+int find( const string & s, size_t fromPos, const char * search ) {
+	return findFrom( *s.inner, fromPos, search );
+}
+
+int find( const string & s, size_t fromPos, const char * search, size_t searchsize ) {
+	return findFrom( *s.inner, fromPos, search, searchsize );
 }
 
 bool includes( const string & s, const string & search ) {
-    return includes( *s.inner, *search.inner );
+	return includes( *s.inner, *search.inner );
 }
 
 bool includes( const string & s, const char * search ) {
-    return includes( *s.inner, search );
+	return includes( *s.inner, search );
 }
 
 bool includes( const string & s, const char * search, size_t searchsize ) {
-    return includes( *s.inner, search, searchsize );
+	return includes( *s.inner, search, searchsize );
 }
 
 bool startsWith( const string & s, const string & prefix ) {
-    return startsWith( *s.inner, *prefix.inner );
+	return startsWith( *s.inner, *prefix.inner );
 }
 
 bool startsWith( const string & s, const char * prefix ) {
-    return startsWith( *s.inner, prefix );
+	return startsWith( *s.inner, prefix );
 }
 
 bool startsWith( const string & s, const char * prefix, size_t prefixsize ) {
-    return startsWith( *s.inner, prefix, prefixsize );
+	return startsWith( *s.inner, prefix, prefixsize );
 }
 
 bool endsWith( const string & s, const string & suffix ) {
-    return endsWith( *s.inner, *suffix.inner );
+	return endsWith( *s.inner, *suffix.inner );
 }
 
 bool endsWith( const string & s, const char * suffix ) {
-    return endsWith( *s.inner, suffix );
+	return endsWith( *s.inner, suffix );
 }
 
 bool endsWith( const string & s, const char * suffix, size_t suffixsize ) {
-    return endsWith( *s.inner, suffix, suffixsize );
+	return endsWith( *s.inner, suffix, suffixsize );
 }
 
@@ -486,27 +491,27 @@
 
 void ?{}( charclass & s, const string & chars ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, *(const string_res *)chars.inner );
+	(s.inner) { malloc() };
+	?{}( *s.inner, *(const string_res *)chars.inner );
 }
 
 void ?{}( charclass & s, const char * chars ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, chars );
+	(s.inner) { malloc() };
+	?{}( *s.inner, chars );
 }
 
 void ?{}( charclass & s, const char * chars, size_t charssize ) {
-    (s.inner) { malloc() };
-    ?{}( *s.inner, chars, charssize );
+	(s.inner) { malloc() };
+	?{}( *s.inner, chars, charssize );
 }
 
 void ^?{}( charclass & s ) {
-    ^(*s.inner){};
-    free( s.inner );
-    s.inner = 0p;
+	^(*s.inner){};
+	free( s.inner );
+	s.inner = 0p;
 }
 
 
 int exclude( const string & s, const charclass & mask ) {
-    return exclude( *s.inner, *mask.inner );
+	return exclude( *s.inner, *mask.inner );
 }
 /*
@@ -516,5 +521,5 @@
 
 int include( const string & s, const charclass & mask ) {
-    return include( *s.inner, *mask.inner );
+	return include( *s.inner, *mask.inner );
 }
 
Index: libcfa/src/collections/string.hfa
===================================================================
--- libcfa/src/collections/string.hfa	(revision e1358c0ea59c560c010e5261b3e1fe2ac3ad8a2c)
+++ libcfa/src/collections/string.hfa	(revision 4223317e3e759f006fdf485a8ab0ebb78ef3c267)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 14 15:33:38 2025
-// Update Count     : 132
+// Last Modified On : Tue Apr  1 09:16:39 2025
+// Update Count     : 155
 //
 
@@ -24,13 +24,18 @@
 
 struct string {
-    string_res * inner;
+	string_res * inner;
 };
 
 // Getters
+//static size_t inline __attribute__((always_inline)) size( char c ) { return sizeof( c ); };	// base case
+//static size_t inline __attribute__((always_inline)) size( wchar_t wc ) { return sizeof( wc ); }; // base case
+static inline size_t size( const char * cs ) { return strlen( cs ); };
+static inline size_t ?`len( const char * cs ) { return size( cs ); };
 size_t size( const string & s );
+size_t ?`len( const string & s ) { return size( s ); }
 static inline size_t strlen( const string & s ) { return size( s ); }
 
 // RAII, assignment
-void ?{}( string & s ); // empty string
+void ?{}( string & s );									// empty string
 void ?{}( string & s, const string & s2 );
 void ?{}( string & s, const string & s2, size_t maxlen );
@@ -48,10 +53,10 @@
 void ?{}( string & s, long double _Complex rhs );
 
-string str( ssize_t rhs );
-string str( size_t rhs );
-string str( double rhs );
-string str( long double rhs );
-string str( double _Complex rhs );
-string str( long double _Complex rhs );
+// string str( ssize_t rhs );
+// string str( size_t rhs );
+// string str( double rhs );
+// string str( long double rhs );
+// string str( double _Complex rhs );
+// string str( long double _Complex rhs );
 
 string & ?=?( string & s, const string & c );
@@ -78,5 +83,5 @@
 // Alternate construction: request shared edits
 struct string_Share {
-    string * s;
+	string * s;
 };
 string_Share ?`share( string & s );
@@ -210,6 +215,6 @@
 
 // Slicing
-string ?()( string & s, size_t start, size_t len );		// TODO const?
-string ?()( string & s, size_t start );
+string ?()( string & s, ssize_t start, ssize_t len );		// TODO const?
+string ?()( string & s, ssize_t start );
 
 // String search
@@ -221,8 +226,8 @@
 int find( const string & s, const char * search, size_t searchsize );
 
-int findFrom( const string & s, size_t fromPos, char search );
-int findFrom( const string & s, size_t fromPos, const string & search );
-int findFrom( const string & s, size_t fromPos, const char * search );
-int findFrom( const string & s, size_t fromPos, const char * search, size_t searchsize );
+int find( const string & s, size_t fromPos, char search );
+int find( const string & s, size_t fromPos, const string & search );
+int find( const string & s, size_t fromPos, const char * search );
+int find( const string & s, size_t fromPos, const char * search, size_t searchsize );
 
 bool includes( const string & s, const string & search );
@@ -246,5 +251,5 @@
 
 struct charclass {
-    charclass_res * inner;
+	charclass_res * inner;
 };