Index: libcfa/src/collections/string.cfa
===================================================================
--- libcfa/src/collections/string.cfa	(revision 8b4faf639e449fe289d559f0202fd6e97f96d2d3)
+++ libcfa/src/collections/string.cfa	(revision 681e12fe6a6c02c012774ae0c71d29db74b18307)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Oct 18 21:52:09 2023
-// Update Count     : 208
+// Last Modified On : Thu Jan  4 11:27:37 2024
+// Update Count     : 233
 //
 
@@ -30,38 +30,38 @@
 
 
-void ?{}( string & this ) {
-    (this.inner) { malloc() };
-    ?{}( *this.inner );
+void ?{}( string & s ) {
+    (s.inner) { malloc() };
+    ?{}( *s.inner );
 }
 
 // private (not in header)
-static void ?{}( string & this, string_res & src, size_t start, size_t end ) {
-    (this.inner) { malloc() };
-    ?{}( *this.inner, src, SHARE_EDITS, start, end );
-}
-
-void ?{}( string & this, const string & other ) {
-    (this.inner) { malloc() };
-    ?{}( *this.inner, *other.inner, COPY_VALUE );
-}
-
-void ?{}( string & this, string & other ) {
-    ?{}( this, (const string &) other );
-}
-
-void ?{}( string & this, const char * val ) {
-    (this.inner) { malloc() };
-    ?{}( *this.inner, val );
-}
-
-void ?{}( string & this, const char * buffer, size_t bsize) {
-    (this.inner) { malloc() };
-    ?{}( *this.inner, buffer, bsize );
-}
-
-void ^?{}( string & this ) {
-    ^(*this.inner){};
-    free( this.inner );
-    this.inner = 0p;
+static void ?{}( string & s, string_res & src, size_t start, size_t end ) {
+    (s.inner) { malloc() };
+    ?{}( *s.inner, src, SHARE_EDITS, start, end );
+}
+
+void ?{}( string & s, const string & c ) {
+    (s.inner) { malloc() };
+    ?{}( *s.inner, *c.inner, COPY_VALUE );
+}
+
+void ?{}( string & s, string & c ) {
+    ?{}( s, (const string &) c );
+}
+
+void ?{}( string & s, const char * val ) {
+    (s.inner) { malloc() };
+    ?{}( *s.inner, val );
+}
+
+void ?{}( string & s, const char * buffer, size_t bsize) {
+    (s.inner) { malloc() };
+    ?{}( *s.inner, buffer, bsize );
+}
+
+void ^?{}( string & s ) {
+    ^(*s.inner){};
+    free( s.inner );
+    s.inner = 0p;
 }
 
@@ -69,11 +69,11 @@
 // Alternate construction: request shared edits
 
-string_WithSharedEdits ?`shareEdits( string & this ) {
-    string_WithSharedEdits ret = { &this };
-    return ret;
-}
-
-void ?{}( string & this, string_WithSharedEdits src ) {
-    ?{}( this, *src.s->inner, 0, src.s->inner->Handle.lnth);
+string_WithSharedEdits ?`shareEdits( string & s ) {
+    string_WithSharedEdits ret = { &s };
+    return ret;
+}
+
+void ?{}( string & s, string_WithSharedEdits src ) {
+    ?{}( s, *src.s->inner, 0, src.s->inner->Handle.lnth);
 }
 
@@ -81,19 +81,19 @@
 // Assignment
 
-void ?=?( string & this, const char * val ) {
-    (*this.inner) = val;
-}
-
-void ?=?(string & this, const string & other) {
-    (*this.inner) = (*other.inner);
-}
-
-void ?=?( string & this, char val ) {
-    (*this.inner) = val;
-}
-
-string & ?=?(string & this, string & other) { //// <---- straw man change
-    (*this.inner) = (*other.inner);
-    return this;
+void ?=?( string & s, const char * val ) {
+    (*s.inner) = val;
+}
+
+void ?=?(string & s, const string & c) {
+    (*s.inner) = (*c.inner);
+}
+
+void ?=?( string & s, char val ) {
+    (*s.inner) = val;
+}
+
+string & ?=?(string & s, string & c) { //// <---- straw man change
+    (*s.inner) = (*c.inner);
+    return s;
 }
 
@@ -102,10 +102,10 @@
 // Input-Output
 
-ofstream & ?|?( ofstream & out, const string & this ) {
-    return out | (*this.inner); // print internal string_res
-}
-
-void ?|?( ofstream & out, const string & this ) {
-    (ofstream &)(out | (*this.inner)); ends( out );
+ofstream & ?|?( ofstream & out, const string & s ) {
+    return out | (*s.inner); // print internal string_res
+}
+
+void ?|?( ofstream & out, const string & s ) {
+    (ofstream &)(out | (*s.inner)); ends( out );
 }
 
@@ -124,10 +124,10 @@
 }
 
-ifstream & ?|?(ifstream & in, string & this) {
-    return in | (*this.inner); // read to internal string_res
-}
-
-void ?|?( ifstream & in, string & this ) {
-    in | (*this.inner);
+ifstream & ?|?(ifstream & in, string & s) {
+    return in | (*s.inner); // read to internal string_res
+}
+
+void ?|?( ifstream & in, string & s ) {
+    in | (*s.inner);
 }
 
@@ -144,11 +144,11 @@
 // Slicing
 
-string ?()( string & this, size_t start, size_t end ) {
-    string ret = { *this.inner, start, end };
+string ?()( string & s, size_t start, size_t end ) {
+    string ret = { *s.inner, start, end };
     return ret`shareEdits;
 }
 
-string ?()( string & this, size_t start ) {
-    string ret = { *this.inner, start, size( this ) };
+string ?()( string & s, size_t start ) {
+    string ret = { *s.inner, start, size( s ) };
     return ret`shareEdits;
 }
@@ -157,27 +157,27 @@
 // Comparison
 
-int  cmp (const string &s1, const string &s2) { return cmp(*s1.inner ,  *s2.inner); }
-bool ?==?(const string &s1, const string &s2) { return     *s1.inner == *s2.inner ; }
-bool ?!=?(const string &s1, const string &s2) { return     *s1.inner != *s2.inner ; }
-bool ?>? (const string &s1, const string &s2) { return     *s1.inner >  *s2.inner ; }
-bool ?>=?(const string &s1, const string &s2) { return     *s1.inner >= *s2.inner ; }
-bool ?<=?(const string &s1, const string &s2) { return     *s1.inner <= *s2.inner ; }
-bool ?<? (const string &s1, const string &s2) { return     *s1.inner <  *s2.inner ; }
-
-int  cmp (const string &s1, const char*   s2) { return cmp(*s1.inner ,   s2      ); }
-bool ?==?(const string &s1, const char*   s2) { return     *s1.inner ==  s2       ; }
-bool ?!=?(const string &s1, const char*   s2) { return     *s1.inner !=  s2       ; }
-bool ?>? (const string &s1, const char*   s2) { return     *s1.inner >   s2       ; }
-bool ?>=?(const string &s1, const char*   s2) { return     *s1.inner >=  s2       ; }
-bool ?<=?(const string &s1, const char*   s2) { return     *s1.inner <=  s2       ; }
-bool ?<? (const string &s1, const char*   s2) { return     *s1.inner <   s2       ; }
-
-int  cmp (const char*   s1, const string &s2) { return cmp( s1       ,  *s2.inner); }
-bool ?==?(const char*   s1, const string &s2) { return      s1       == *s2.inner ; }
-bool ?!=?(const char*   s1, const string &s2) { return      s1       != *s2.inner ; }
-bool ?>? (const char*   s1, const string &s2) { return      s1       >  *s2.inner ; }
-bool ?>=?(const char*   s1, const string &s2) { return      s1       >= *s2.inner ; }
-bool ?<=?(const char*   s1, const string &s2) { return      s1       <= *s2.inner ; }
-bool ?<? (const char*   s1, const string &s2) { return      s1       <  *s2.inner ; }
+int  strcmp(const string & s1, const string & s2) { return strcmp(*s1.inner, *s2.inner); }
+bool ?==?(const string & s1, const string & s2) { return *s1.inner == *s2.inner; }
+bool ?!=?(const string & s1, const string & s2) { return *s1.inner != *s2.inner; }
+bool ?>? (const string & s1, const string & s2) { return *s1.inner >  *s2.inner; }
+bool ?>=?(const string & s1, const string & s2) { return *s1.inner >= *s2.inner; }
+bool ?<=?(const string & s1, const string & s2) { return *s1.inner <= *s2.inner; }
+bool ?<? (const string & s1, const string & s2) { return *s1.inner <  *s2.inner; }
+
+int  strcmp(const string & s1, const char * s2) { return strcmp(*s1.inner, s2 ); }
+bool ?==?(const string & s1, const char * s2) { return *s1.inner == s2; }
+bool ?!=?(const string & s1, const char * s2) { return *s1.inner != s2; }
+bool ?>? (const string & s1, const char * s2) { return *s1.inner >  s2; }
+bool ?>=?(const string & s1, const char * s2) { return *s1.inner >= s2; }
+bool ?<=?(const string & s1, const char * s2) { return *s1.inner <= s2; }
+bool ?<? (const string & s1, const char * s2) { return *s1.inner <  s2; }
+
+int  strcmp(const char * s1, const string & s2) { return strcmp( s1, *s2.inner); }
+bool ?==?(const char * s1, const string & s2) { return s1 == *s2.inner; }
+bool ?!=?(const char * s1, const string & s2) { return s1 != *s2.inner; }
+bool ?>? (const char * s1, const string & s2) { return s1 >  *s2.inner; }
+bool ?>=?(const char * s1, const string & s2) { return s1 >= *s2.inner; }
+bool ?<=?(const char * s1, const string & s2) { return s1 <= *s2.inner; }
+bool ?<? (const char * s1, const string & s2) { return s1 <  *s2.inner; }
 
 
@@ -186,5 +186,5 @@
 
 size_t size(const string & s) {
-    return size( * s.inner );
+    return size( *s.inner );
 }
 
@@ -192,6 +192,6 @@
 // Concatenation
 
-void ?+=?(string & s, char other) {
-    (*s.inner) += other;
+void ?+=?(string & s, char c) {
+    (*s.inner) += c;
 }
 
@@ -200,11 +200,11 @@
 }
 
-void ?+=?(string & s, const char * other) {
-    (*s.inner) += other;
-}
-
-string ?+?(const string & s, char other) {
+void ?+=?(string & s, const char * c) {
+    (*s.inner) += c;
+}
+
+string ?+?(const string & s, char c) {
     string ret = s;
-    ret += other;
+    ret += c;
     return ret;
 }
@@ -222,7 +222,7 @@
 }
 
-string ?+?(const string & s, const char * other) {
+string ?+?(const string & s, const char * c) {
     string ret = s;
-    ret += other;
+    ret += c;
     return ret;
 }
@@ -339,23 +339,23 @@
 // charclass, include, exclude
 
-void ?{}( charclass & this, const string & chars) {
-    (this.inner) { malloc() };
-    ?{}( *this.inner, *(const string_res *)chars.inner );
-}
-
-void ?{}( charclass & this, const char * chars ) {
-    (this.inner) { malloc() };
-    ?{}( *this.inner, chars );
-}
-
-void ?{}( charclass & this, const char * chars, size_t charssize ) {
-    (this.inner) { malloc() };
-    ?{}( *this.inner, chars, charssize );
-}
-
-void ^?{}( charclass & this ) {
-    ^(*this.inner){};
-    free( this.inner );
-    this.inner = 0p;
+void ?{}( charclass & s, const string & chars) {
+    (s.inner) { malloc() };
+    ?{}( *s.inner, *(const string_res *)chars.inner );
+}
+
+void ?{}( charclass & s, const char * chars ) {
+    (s.inner) { malloc() };
+    ?{}( *s.inner, chars );
+}
+
+void ?{}( charclass & s, const char * chars, size_t charssize ) {
+    (s.inner) { malloc() };
+    ?{}( *s.inner, chars, charssize );
+}
+
+void ^?{}( charclass & s ) {
+    ^(*s.inner){};
+    free( s.inner );
+    s.inner = 0p;
 }
 
Index: libcfa/src/collections/string.hfa
===================================================================
--- libcfa/src/collections/string.hfa	(revision 8b4faf639e449fe289d559f0202fd6e97f96d2d3)
+++ libcfa/src/collections/string.hfa	(revision 681e12fe6a6c02c012774ae0c71d29db74b18307)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Sep  2 11:26:28 2023
-// Update Count     : 55
+// Last Modified On : Thu Jan  4 11:27:35 2024
+// Update Count     : 75
 //
 
@@ -29,7 +29,8 @@
 // Getters
 size_t size(const string & s);
+static inline size_t strlen(const string & s) { return size( s ); }
 
 // RAII, assignment
-void ?{}(string & this); // empty string
+void ?{}(string & s); // empty string
 void ?{}(string & s, const char * initial); // copy from string literal (NULL-terminated)
 void ?{}(string & s, const char * buffer, size_t bsize); // copy specific length from buffer
@@ -38,8 +39,10 @@
 void ?{}(string & s, string & s2);
 
-void ?=?(string & s, const char * other); // copy assignment from literal
-void ?=?(string & s, const string & other);
-void ?=?(string & s, char other);
-string & ?=?(string & s, string & other);  // surprising ret seems to help avoid calls to autogen
+void ?=?(string & s, const char * c); // copy assignment from literal
+static inline string & strcpy(string & s, const char * c) { s = c; return s; }
+void ?=?(string & s, const string & c);
+static inline string & strcpy(string & s, const string c) { s = c; return s; }
+void ?=?(string & s, char c);
+string & ?=?(string & s, string & c);  // surprising ret seems to help avoid calls to autogen
 //string ?=?( string &, string ) = void;
 void ^?{}(string & s);
@@ -49,6 +52,6 @@
     string * s;
 };
-string_WithSharedEdits ?`shareEdits( string & this );
-void ?{}( string & this, string_WithSharedEdits src );
+string_WithSharedEdits ?`shareEdits( string & s );
+void ?{}( string & s, string_WithSharedEdits src );
 
 // IO Operator
@@ -56,5 +59,5 @@
 void ?|?(ofstream & out, const string & s);
 ifstream & ?|?(ifstream & in, string & s);
-void ?|?( ifstream & in, string & this );
+void ?|?( ifstream & in, string & s );
 
 static inline {
@@ -81,8 +84,8 @@
 	_Istream_Sstr wdi( unsigned int rwd, string & s ) { return (_Istream_Sstr)@{ s, {{0p}, rwd, {.flags.rwd : true}} }; }
 	_Istream_Sstr getline( string & s, const char delimiter = '\n' ) {
-		return (_Istream_Sstr)@{ s, {{.delimiter : { delimiter, '\0' } }, -1, {.flags.delimiter : true, .flags.inex : true}} };
+		return (_Istream_Sstr)@{ s, {{.delimiters : { delimiter, '\0' } }, -1, {.flags.delimiter : true, .flags.inex : true}} };
 	}
 	_Istream_Sstr & getline( _Istream_Sstr & fmt, const char delimiter = '\n' ) {
-		fmt.delimiter[0] = delimiter; fmt.delimiter[1] = '\0'; fmt.flags.delimiter = true; fmt.flags.inex = true; return fmt;
+		fmt.delimiters[0] = delimiter; fmt.delimiters[1] = '\0'; fmt.flags.delimiter = true; fmt.flags.inex = true; return fmt;
 	}
 	_Istream_Sstr incl( const char scanset[], string & s ) { return (_Istream_Sstr)@{ s, {{scanset}, -1, {.flags.inex : false}} }; }
@@ -97,11 +100,13 @@
 
 // Concatenation
-void ?+=?(string & s, char other); // append a character
+void ?+=?(string & s, char c); // append a character
 void ?+=?(string & s, const string & s2); // append-concatenate to first string
-void ?+=?(string & s, const char * other); // append-concatenate to first string
-string ?+?(const string & s, char other); // add a character to a copy of the string
+static inline string & strcat(string & s, const string & s2) { s += s2; return s; }
+void ?+=?(string & s, const char * s2); // append-concatenate to first string
+static inline string & strcat(string & s, const char * c) { s += c; return s; }
+string ?+?(const string & s, char c); // add a character to a copy of the string
 string ?+?(const string & s, const string & s2); // copy and concatenate both strings
 string ?+?(const char * s1, const char * s2); // concatenate both strings
-string ?+?(const string & s, const char * other); // copy and concatenate with NULL-terminated string
+string ?+?(const string & s, const char * c); // copy and concatenate with NULL-terminated string
 
 // Repetition
@@ -116,5 +121,5 @@
 
 // Comparisons
-int  cmp (const string &, const string &);
+int  strcmp (const string &, const string &);
 bool ?==?(const string &, const string &);
 bool ?!=?(const string &, const string &);
@@ -124,24 +129,24 @@
 bool ?<? (const string &, const string &);
 
-int  cmp (const string &, const char*);
-bool ?==?(const string &, const char*);
-bool ?!=?(const string &, const char*);
-bool ?>? (const string &, const char*);
-bool ?>=?(const string &, const char*);
-bool ?<=?(const string &, const char*);
-bool ?<? (const string &, const char*);
-
-int  cmp (const char*, const string &);
-bool ?==?(const char*, const string &);
-bool ?!=?(const char*, const string &);
-bool ?>? (const char*, const string &);
-bool ?>=?(const char*, const string &);
-bool ?<=?(const char*, const string &);
-bool ?<? (const char*, const string &);
+int  strcmp (const string &, const char *);
+bool ?==?(const string &, const char *);
+bool ?!=?(const string &, const char *);
+bool ?>? (const string &, const char *);
+bool ?>=?(const string &, const char *);
+bool ?<=?(const string &, const char *);
+bool ?<? (const string &, const char *);
+
+int  strcmp (const char *, const string &);
+bool ?==?(const char *, const string &);
+bool ?!=?(const char *, const string &);
+bool ?>? (const char *, const string &);
+bool ?>=?(const char *, const string &);
+bool ?<=?(const char *, const string &);
+bool ?<? (const char *, const string &);
 
 
 // Slicing
-string ?()( string & this, size_t start, size_t end );  // TODO const?
-string ?()( string & this, size_t start);
+string ?()( string & s, size_t start, size_t end );  // TODO const?
+string ?()( string & s, size_t start);
 
 // String search
@@ -177,5 +182,4 @@
 
 
-
 struct charclass {
     charclass_res * inner;
Index: libcfa/src/collections/string_res.cfa
===================================================================
--- libcfa/src/collections/string_res.cfa	(revision 8b4faf639e449fe289d559f0202fd6e97f96d2d3)
+++ libcfa/src/collections/string_res.cfa	(revision 681e12fe6a6c02c012774ae0c71d29db74b18307)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Oct 18 21:54:54 2023
-// Update Count     : 15
+// Last Modified On : Tue Jan  2 13:20:27 2024
+// Update Count     : 34
 //
 
@@ -22,5 +22,5 @@
 // Workaround is:  EndVbyte = TEMP_ALLOC(char, CurrSize)
 // Should be:      EndVbyte = alloc(CurrSize)
-#define TEMP_ALLOC(T, n) (( T* ) malloc( n * sizeof( T ) ))
+#define TEMP_ALLOC(T, n) (( T * ) malloc( n * sizeof( T ) ))
 
 #include <assert.h>
@@ -33,21 +33,20 @@
 
 struct VbyteHeap {
-
-    int NoOfCompactions;				// number of compactions of the byte area
-    int NoOfExtensions;					// number of extensions in the size of the byte area
-    int NoOfReductions;					// number of reductions in the size of the byte area
+    int NoOfCompactions;						// number of compactions of the byte area
+    int NoOfExtensions;							// number of extensions in the size of the byte area
+    int NoOfReductions;							// number of reductions in the size of the byte area
     
-    int InitSize;					// initial number of bytes in the byte-string area
-    int CurrSize;					// current number of bytes in the byte-string area
-    char *StartVbyte;					// pointer to the `st byte of the start of the byte-string area
-    char *EndVbyte;					// pointer to the next byte after the end of the currently used portion of byte-string area
-    void *ExtVbyte;					// pointer to the next byte after the end of the byte-string area
-
-    HandleNode Header;					// header node for handle list
+    int InitSize;								// initial number of bytes in the byte-string area
+    int CurrSize;								// current number of bytes in the byte-string area
+    char *StartVbyte;							// pointer to the `st byte of the start of the byte-string area
+    char *EndVbyte;								// pointer to the next byte after the end of the currently used portion of byte-string area
+    void *ExtVbyte;								// pointer to the next byte after the end of the byte-string area
+
+    HandleNode Header;							// header node for handle list
 }; // VbyteHeap
 
     
-static void compaction( VbyteHeap & );				// compaction of the byte area
-static void garbage( VbyteHeap &, int );				// garbage collect the byte area
+static void compaction( VbyteHeap & );			// compaction of the byte area
+static void garbage( VbyteHeap &, int );		// garbage collect the byte area
 static void extend( VbyteHeap &, int );			// extend the size of the byte area
 static void reduce( VbyteHeap &, int );			// reduce the size of the byte area
@@ -67,7 +66,7 @@
 // Allocate the storage for the variable sized area and intialize the heap variables.
 
-static void ?{}( VbyteHeap & this, size_t Size ) with(this) {
-#ifdef VbyteDebug
-    serr | "enter:VbyteHeap::VbyteHeap, this:" | &this | " Size:" | Size;
+static void ?{}( VbyteHeap & s, size_t Size ) with(s) {
+#ifdef VbyteDebug
+    serr | "enter:VbyteHeap::VbyteHeap, s:" | &s | " Size:" | Size;
 #endif // VbyteDebug
     NoOfCompactions = NoOfExtensions = NoOfReductions = 0;
@@ -76,8 +75,8 @@
     ExtVbyte = (void *)( StartVbyte + CurrSize );
     Header.flink = Header.blink = &Header;
-    Header.ulink = & this;
+    Header.ulink = &s;
 #ifdef VbyteDebug
     HeaderPtr = &Header;
-    serr | "exit:VbyteHeap::VbyteHeap, this:" | &this;
+    serr | "exit:VbyteHeap::VbyteHeap, s:" | &s;
 #endif // VbyteDebug
 } // VbyteHeap
@@ -86,5 +85,5 @@
 // Release the dynamically allocated storage for the byte area.
 
-static void ^?{}( VbyteHeap & this ) with(this) {
+static void ^?{}( VbyteHeap & s ) with(s) {
     free( StartVbyte );
 } // ~VbyteHeap
@@ -97,12 +96,12 @@
 // creator.
 
-static void ?{}( HandleNode & this ) with(this) {
-#ifdef VbyteDebug
-    serr | "enter:HandleNode::HandleNode, this:" | &this;
+static void ?{}( HandleNode & s ) with(s) {
+#ifdef VbyteDebug
+    serr | "enter:HandleNode::HandleNode, s:" | &s;
 #endif // VbyteDebug
     s = 0;
     lnth = 0;
 #ifdef VbyteDebug
-    serr | "exit:HandleNode::HandleNode, this:" | &this;
+    serr | "exit:HandleNode::HandleNode, s:" | &s;
 #endif // VbyteDebug
 } // HandleNode
@@ -112,14 +111,14 @@
 // collection.
 
-static void ?{}( HandleNode & this, VbyteHeap & vh ) with(this) {
-#ifdef VbyteDebug
-    serr | "enter:HandleNode::HandleNode, this:" | &this;
+static void ?{}( HandleNode & s, VbyteHeap & vh ) with(s) {
+#ifdef VbyteDebug
+    serr | "enter:HandleNode::HandleNode, s:" | &s;
 #endif // VbyteDebug
     s = 0;
     lnth = 0;
     ulink = &vh;
-    AddThisAfter( this, *vh.Header.blink );
-#ifdef VbyteDebug
-    serr | "exit:HandleNode::HandleNode, this:" | &this;
+    AddThisAfter( s, *vh.Header.blink );
+#ifdef VbyteDebug
+    serr | "exit:HandleNode::HandleNode, s:" | &s;
 #endif // VbyteDebug
 } // HandleNode
@@ -129,7 +128,7 @@
 // is the responsibility of the creator to destroy it.
 
-static void ^?{}( HandleNode & this ) with(this) {
-#ifdef VbyteDebug
-    serr | "enter:HandleNode::~HandleNode, this:" | & this;
+static void ^?{}( HandleNode & s ) with(s) {
+#ifdef VbyteDebug
+    serr | "enter:HandleNode::~HandleNode, s:" | & s;
     {
 	serr | nlOff;
@@ -142,5 +141,5 @@
     }
 #endif // VbyteDebug
-    DeleteNode( this );
+    DeleteNode( s );
 } // ~HandleNode
 
@@ -151,5 +150,5 @@
 static string_sharectx default_string_sharectx = {NEW_SHARING}; // stable bottom of stack
 
-void ?{}( string_sharectx & this, StringSharectx_Mode mode ) with( this ) {
+void ?{}( string_sharectx & s, StringSharectx_Mode mode ) with( s ) {
     (older){ ambient_string_sharectx };
     if ( mode == NEW_SHARING ) {
@@ -159,15 +158,15 @@
         (activeHeap){ 0p };
     }
-    ambient_string_sharectx = & this;
-}
-
-void ^?{}( string_sharectx & this ) with( this ) {
+    ambient_string_sharectx = & s;
+}
+
+void ^?{}( string_sharectx & s ) with( s ) {
     if ( activeHeap ) delete( activeHeap );
 
-    // unlink this from older-list starting from ambient_string_sharectx
-    // usually, this==ambient_string_sharectx and the loop runs zero times
+    // unlink s from older-list starting from ambient_string_sharectx
+    // usually, s==ambient_string_sharectx and the loop runs zero times
     string_sharectx *& c = ambient_string_sharectx;
-    while ( c != &this ) &c = &c->older;              // find this
-    c = this.older;                                   // unlink
+    while ( c != &s ) &c = &c->older;              // find s
+    c = s.older;                                   // unlink
 }
 
@@ -193,10 +192,10 @@
 
 // Returns the size of the string in bytes
-size_t size(const string_res &s) with(s) {
+size_t size(const string_res & s) with(s) {
     return Handle.lnth;
 }
 
 // Output operator
-ofstream & ?|?(ofstream &out, const string_res &s) {
+ofstream & ?|?(ofstream & out, const string_res & s) {
 	// CFA string is NOT null terminated, so print exactly lnth characters in a minimum width of 0.
 	out | wd( 0, s.Handle.lnth, s.Handle.s ) | nonl;
@@ -204,11 +203,10 @@
 }
 
-void ?|?(ofstream &out, const string_res &s) {
+void ?|?(ofstream & out, const string_res & s) {
 	(ofstream &)(out | s); ends( out );
 }
 
 // Input operator
-ifstream & ?|?(ifstream &in, string_res &s) {
-
+ifstream & ?|?(ifstream & in, string_res & s) {
     // Reading into a temp before assigning to s is near zero overhead in typical cases because of sharing.
     // If s is a substring of something larger, simple assignment takes care of that case correctly.
@@ -238,5 +236,5 @@
 			*(temp.Handle.ulink->EndVbyte) = '\0';   // pre-assign empty cstring
             in | wdi( lenReadable, temp.Handle.ulink->EndVbyte );
-        } catch (cstring_length*) {
+        } catch (cstring_length *) {
             cont = true;
         }
@@ -252,6 +250,6 @@
 }
 
-void ?|?( ifstream & in, string_res & this ) {
-    (ifstream &)(in | this);
+void ?|?( ifstream & in, string_res & s ) {
+    (ifstream &)(in | s);
 }
 
@@ -274,6 +272,7 @@
 		cont = true;
 	} finally {
-		if ( ! cf.flags.ignore &&						// ok to initialize string
-				cstr[0] != '\0' ) {						// something was read
+		if ( ! cf.flags.ignore							// ok to initialize string
+//			 &&	cstr[0] != '\0'							// something was read
+			) {
 			*(f.s) = cstr;
 		}
@@ -287,6 +286,5 @@
 			cont = true;								// continue not allowed
 		} finally {
-			if ( ! cf.flags.ignore &&
-					cstr[0] != '\0' ) {					// something was read
+			if ( ! cf.flags.ignore && cstr[0] != '\0' ) { // something was read
 				*(f.s) += cstr;							// build string chunk at a time
 			}
@@ -302,5 +300,5 @@
 
 // Empty constructor
-void ?{}(string_res &s) with(s) {
+void ?{}(string_res & s) with(s) {
     if( ambient_string_sharectx->activeHeap ) {
         (Handle){ * ambient_string_sharectx->activeHeap };
@@ -317,5 +315,5 @@
 }
 
-static void eagerCopyCtorHelper(string_res &s, const char* rhs, size_t rhslnth) with(s) {
+static void eagerCopyCtorHelper(string_res & s, const char* rhs, size_t rhslnth) with(s) {
     if( ambient_string_sharectx->activeHeap ) {
         (Handle){ * ambient_string_sharectx->activeHeap };
@@ -333,10 +331,10 @@
 
 // Constructor from a raw buffer and size
-void ?{}(string_res &s, const char* rhs, size_t rhslnth) with(s) {
+void ?{}(string_res & s, const char* rhs, size_t rhslnth) with(s) {
     eagerCopyCtorHelper(s, rhs, rhslnth);
 }
 
 // private ctor (not in header): use specified heap (ignore ambient) and copy chars in
-void ?{}( string_res &s, VbyteHeap & heap, const char* rhs, size_t rhslnth ) with(s) {
+void ?{}( string_res & s, VbyteHeap & heap, const char* rhs, size_t rhslnth ) with(s) {
     (Handle){ heap };
     Handle.s = VbyteAlloc(*Handle.ulink, rhslnth);
@@ -349,5 +347,5 @@
 
 // General copy constructor
-void ?{}(string_res &s, const string_res & s2, StrResInitMode mode, size_t start, size_t end ) {
+void ?{}(string_res & s, const string_res & s2, StrResInitMode mode, size_t start, size_t end ) {
 
     verify( start <= end && end <= s2.Handle.lnth );
@@ -394,5 +392,5 @@
 }
 
-static void assignEditSet(string_res & this, string_res * shareEditSetStartPeer, string_res * shareEditSetEndPeer,
+static void assignEditSet(string_res & s, string_res * shareEditSetStartPeer, string_res * shareEditSetEndPeer,
     char * resultSesStart,
     size_t resultSesLnth,
@@ -400,19 +398,19 @@
 
     char * beforeBegin = shareEditSetStartPeer->Handle.s;
-    size_t beforeLen = this.Handle.s - beforeBegin;
-
-    char * afterBegin = this.Handle.s + this.Handle.lnth;
+    size_t beforeLen = s.Handle.s - beforeBegin;
+
+    char * afterBegin = s.Handle.s + s.Handle.lnth;
     size_t afterLen = shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth - afterBegin;
 
-    size_t oldLnth = this.Handle.lnth;
-
-    this.Handle.s = resultSesStart + beforeLen;
-    this.Handle.lnth = bsize;
+    size_t oldLnth = s.Handle.lnth;
+
+    s.Handle.s = resultSesStart + beforeLen;
+    s.Handle.lnth = bsize;
     if (resultPadPosition)
-        MoveThisAfter( this.Handle, *resultPadPosition );
+        MoveThisAfter( s.Handle, *resultPadPosition );
 
     // adjust all substring string and handle locations, and check if any substring strings are outside the new base string
     char *limit = resultSesStart + resultSesLnth;
-    for ( string_res * p = this.shareEditSet_next; p != &this; p = p->shareEditSet_next ) {
+    for ( string_res * p = s.shareEditSet_next; p != &s; p = p->shareEditSet_next ) {
         verify (p->Handle.s >= beforeBegin);
         if ( p->Handle.s >= afterBegin ) {
@@ -439,5 +437,5 @@
                 // take end as end-anchored
                 // stretch-shrink p according to the edit
-                p->Handle.lnth += this.Handle.lnth;
+                p->Handle.lnth += s.Handle.lnth;
                 p->Handle.lnth -= oldLnth;
             }
@@ -452,5 +450,5 @@
                 // p ends during the edit; p does not include the last character replaced
                 // set p to empty string at start of edit
-                p->Handle.s = this.Handle.s;
+                p->Handle.s = s.Handle.s;
                 p->Handle.lnth = 0;
             } else {
@@ -458,5 +456,5 @@
                 // clip start of p to start at end of edit
                 int charsToClip = afterBegin - p->Handle.s;
-                p->Handle.s = this.Handle.s + this.Handle.lnth;
+                p->Handle.s = s.Handle.s + s.Handle.lnth;
                 p->Handle.lnth -= charsToClip;
             }
@@ -467,9 +465,9 @@
 }
 
-// traverse the share-edit set (SES) to recover the range of a base string to which `this` belongs
-static void locateInShareEditSet( string_res &this, string_res *&shareEditSetStartPeer, string_res *&shareEditSetEndPeer ) {
-    shareEditSetStartPeer = & this;
-    shareEditSetEndPeer = & this;
-    for (string_res * editPeer = this.shareEditSet_next; editPeer != &this; editPeer = editPeer->shareEditSet_next) {
+// traverse the share-edit set (SES) to recover the range of a base string to which `s` belongs
+static void locateInShareEditSet( string_res & s, string_res *& shareEditSetStartPeer, string_res *& shareEditSetEndPeer ) {
+    shareEditSetStartPeer = & s;
+    shareEditSetEndPeer = & s;
+    for (string_res * editPeer = s.shareEditSet_next; editPeer != &s; editPeer = editPeer->shareEditSet_next) {
         if ( editPeer->Handle.s < shareEditSetStartPeer->Handle.s ) {
             shareEditSetStartPeer = editPeer;
@@ -481,29 +479,29 @@
 }
 
-static string_res & assign_(string_res &this, const char* buffer, size_t bsize, const string_res & valSrc) {
+static string_res & assign_(string_res & s, const char* buffer, size_t bsize, const string_res & valSrc) {
 
     string_res * shareEditSetStartPeer;
     string_res * shareEditSetEndPeer;
-    locateInShareEditSet( this, shareEditSetStartPeer, shareEditSetEndPeer );
+    locateInShareEditSet( s, shareEditSetStartPeer, shareEditSetEndPeer );
 
     verify( shareEditSetEndPeer->Handle.s >= shareEditSetStartPeer->Handle.s );
     size_t origEditSetLength = shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth - shareEditSetStartPeer->Handle.s;
-    verify( origEditSetLength >= this.Handle.lnth );
-
-    if ( this.shareEditSet_owns_ulink ) {                 // assigning to private context
+    verify( origEditSetLength >= s.Handle.lnth );
+
+    if ( s.shareEditSet_owns_ulink ) {                 // assigning to private context
         // ok to overwrite old value within LHS
         char * prefixStartOrig = shareEditSetStartPeer->Handle.s;
-        int prefixLen = this.Handle.s - prefixStartOrig;
-        char * suffixStartOrig = this.Handle.s + this.Handle.lnth;
+        int prefixLen = s.Handle.s - prefixStartOrig;
+        char * suffixStartOrig = s.Handle.s + s.Handle.lnth;
         int suffixLen = shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth - suffixStartOrig;
 
-        int delta = bsize - this.Handle.lnth;
-        if ( char * oldBytes = VbyteTryAdjustLast( *this.Handle.ulink, delta ) ) {
+        int delta = bsize - s.Handle.lnth;
+        if ( char * oldBytes = VbyteTryAdjustLast( *s.Handle.ulink, delta ) ) {
             // growing: copy from old to new
-            char * dest = VbyteAlloc( *this.Handle.ulink, origEditSetLength + delta );
+            char * dest = VbyteAlloc( *s.Handle.ulink, origEditSetLength + delta );
             char *destCursor = dest;  memcpy(destCursor, prefixStartOrig, prefixLen);
             destCursor += prefixLen;  memcpy(destCursor, buffer         , bsize    );
             destCursor += bsize;      memcpy(destCursor, suffixStartOrig, suffixLen);
-            assignEditSet(this, shareEditSetStartPeer, shareEditSetEndPeer, 
+            assignEditSet(s, shareEditSetStartPeer, shareEditSetEndPeer, 
                 dest,
                 origEditSetLength + delta,
@@ -513,7 +511,7 @@
             // room is already allocated in-place: bubble suffix and overwite middle
             memmove( suffixStartOrig + delta, suffixStartOrig, suffixLen );
-            memcpy( this.Handle.s, buffer, bsize );
-
-            assignEditSet(this, shareEditSetStartPeer, shareEditSetEndPeer, 
+            memcpy( s.Handle.s, buffer, bsize );
+
+            assignEditSet(s, shareEditSetStartPeer, shareEditSetEndPeer, 
                 shareEditSetStartPeer->Handle.s,
                 origEditSetLength + delta,
@@ -522,10 +520,10 @@
 
     } else if (                                           // assigning to shared context
-        this.Handle.lnth == origEditSetLength &&          // overwriting entire run of SES
+        s.Handle.lnth == origEditSetLength &&          // overwriting entire run of SES
         & valSrc &&                                       // sourcing from a managed string
-        valSrc.Handle.ulink == this.Handle.ulink  ) {     // sourcing from same heap
+        valSrc.Handle.ulink == s.Handle.ulink  ) {     // sourcing from same heap
 
         // SES's result will only use characters from the source string => reuse source
-        assignEditSet(this, shareEditSetStartPeer, shareEditSetEndPeer, 
+        assignEditSet(s, shareEditSetStartPeer, shareEditSetEndPeer, 
             valSrc.Handle.s,
             valSrc.Handle.lnth,
@@ -537,24 +535,24 @@
 
         // full string is from start of shareEditSetStartPeer thru end of shareEditSetEndPeer
-        // `this` occurs in the middle of it, to be replaced
+        // `s` occurs in the middle of it, to be replaced
         // build up the new text in `pasting`
 
         string_res pasting = {
-            * this.Handle.ulink,                               // maintain same heap, regardless of context
+            * s.Handle.ulink,                               // maintain same heap, regardless of context
             shareEditSetStartPeer->Handle.s,                   // start of SES
-            this.Handle.s - shareEditSetStartPeer->Handle.s }; // length of SES, before this
+            s.Handle.s - shareEditSetStartPeer->Handle.s }; // length of SES, before s
         append( pasting,
-            buffer,                                            // start of replacement for this
-            bsize );                                           // length of replacement for this
+            buffer,                                            // start of replacement for s
+            bsize );                                           // length of replacement for s
         append( pasting,
-            this.Handle.s + this.Handle.lnth,                  // start of SES after this
+            s.Handle.s + s.Handle.lnth,                  // start of SES after s
             shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth -
-            (this.Handle.s + this.Handle.lnth) );              // length of SES, after this
+            (s.Handle.s + s.Handle.lnth) );              // length of SES, after s
 
         // The above string building can trigger compaction.
         // The reference points (that are arguments of the string building) may move during that building.
-        // From this point on, they are stable.
-
-        assignEditSet(this, shareEditSetStartPeer, shareEditSetEndPeer, 
+        // From s point on, they are stable.
+
+        assignEditSet(s, shareEditSetStartPeer, shareEditSetEndPeer, 
             pasting.Handle.s,
             pasting.Handle.lnth,
@@ -562,28 +560,28 @@
     }
 
-    return this;
-}
-
-string_res & assign(string_res &this, const char* buffer, size_t bsize) {
-    return assign_(this, buffer, bsize, *0p);
-}
-
-string_res & ?=?(string_res &s, char other) {
-    return assign(s, &other, 1);
+    return s;
+}
+
+string_res & assign(string_res & s, const char* buffer, size_t bsize) {
+    return assign_(s, buffer, bsize, *0p);
+}
+
+string_res & ?=?(string_res & s, char c) {
+    return assign(s, &c, 1);
 }
 
 // Copy assignment operator
-string_res & ?=?(string_res & this, const string_res & rhs) with( this ) {
-    return assign_(this, rhs.Handle.s, rhs.Handle.lnth, rhs);
-}
-
-string_res & ?=?(string_res & this, string_res & rhs) with( this ) {
+string_res & ?=?(string_res & s, const string_res & rhs) with( s ) {
+    return assign_(s, rhs.Handle.s, rhs.Handle.lnth, rhs);
+}
+
+string_res & ?=?(string_res & s, string_res & rhs) with( s ) {
     const string_res & rhs2 = rhs;
-    return this = rhs2;
+    return s = rhs2;
 }
 
 
 // Destructor
-void ^?{}(string_res &s) with(s) {
+void ^?{}(string_res & s) with(s) {
     // much delegated to implied ^VbyteSM
 
@@ -603,10 +601,10 @@
 // With unicode support, this may be different from just the byte at the given
 // offset from the start of the string.
-char ?[?](const string_res &s, size_t index) with(s) {
+char ?[?](const string_res & s, size_t index) with(s) {
     //TODO: Check if index is valid (no exceptions yet)
     return Handle.s[index];
 }
 
-void assignAt(const string_res &s, size_t index, char val) {
+void assignAt(const string_res & s, size_t index, char val) {
     string_res editZone = { s, SHARE_EDITS, index, index+1 };
     assign(editZone, &val, 1);
@@ -617,5 +615,5 @@
 // Concatenation
 
-void append(string_res &str1, const char * buffer, size_t bsize) {
+void append(string_res & str1, const char * buffer, size_t bsize) {
     size_t clnth = str1.Handle.lnth + bsize;
     if ( str1.Handle.s + str1.Handle.lnth == buffer ) { // already juxtapose ?
@@ -635,14 +633,11 @@
 }
 
-void ?+=?(string_res &str1, const string_res &str2) {
+void ?+=?(string_res & str1, const string_res & str2) {
     append( str1, str2.Handle.s, str2.Handle.lnth );
 }
 
-void ?+=?(string_res &s, char other) {
-    append( s, &other, 1 );
-}
-
-
-
+void ?+=?(string_res & s, char c) {
+    append( s, & c, 1 );
+}
 
 
@@ -650,5 +645,5 @@
 // Comparisons
 
-int cmp(const string_res &s1, const string_res &s2) {
+int strcmp(const string_res & s1, const string_res & s2) {
     // return 0;
     int ans1 = memcmp(s1.Handle.s, s2.Handle.s, min(s1.Handle.lnth, s2.Handle.lnth));
@@ -657,34 +652,34 @@
 }
 
-bool ?==?(const string_res &s1, const string_res &s2) { return cmp(s1, s2) == 0; }
-bool ?!=?(const string_res &s1, const string_res &s2) { return cmp(s1, s2) != 0; }
-bool ?>? (const string_res &s1, const string_res &s2) { return cmp(s1, s2) >  0; }
-bool ?>=?(const string_res &s1, const string_res &s2) { return cmp(s1, s2) >= 0; }
-bool ?<=?(const string_res &s1, const string_res &s2) { return cmp(s1, s2) <= 0; }
-bool ?<? (const string_res &s1, const string_res &s2) { return cmp(s1, s2) <  0; }
-
-int cmp (const string_res &s1, const char* s2) {
+bool ?==?(const string_res & s1, const string_res & s2) { return strcmp(s1, s2) == 0; }
+bool ?!=?(const string_res & s1, const string_res & s2) { return strcmp(s1, s2) != 0; }
+bool ?>? (const string_res & s1, const string_res & s2) { return strcmp(s1, s2) >  0; }
+bool ?>=?(const string_res & s1, const string_res & s2) { return strcmp(s1, s2) >= 0; }
+bool ?<=?(const string_res & s1, const string_res & s2) { return strcmp(s1, s2) <= 0; }
+bool ?<? (const string_res & s1, const string_res & s2) { return strcmp(s1, s2) <  0; }
+
+int strcmp (const string_res & s1, const char* s2) {
     string_res s2x = s2;
-    return cmp(s1, s2x);
-}
-
-bool ?==?(const string_res &s1, const char* s2) { return cmp(s1, s2) == 0; }
-bool ?!=?(const string_res &s1, const char* s2) { return cmp(s1, s2) != 0; }
-bool ?>? (const string_res &s1, const char* s2) { return cmp(s1, s2) >  0; }
-bool ?>=?(const string_res &s1, const char* s2) { return cmp(s1, s2) >= 0; }
-bool ?<=?(const string_res &s1, const char* s2) { return cmp(s1, s2) <= 0; }
-bool ?<? (const string_res &s1, const char* s2) { return cmp(s1, s2) <  0; }
-
-int cmp (const char* s1, const string_res & s2) {
+    return strcmp(s1, s2x);
+}
+
+bool ?==?(const string_res & s1, const char* s2) { return strcmp(s1, s2) == 0; }
+bool ?!=?(const string_res & s1, const char* s2) { return strcmp(s1, s2) != 0; }
+bool ?>? (const string_res & s1, const char* s2) { return strcmp(s1, s2) >  0; }
+bool ?>=?(const string_res & s1, const char* s2) { return strcmp(s1, s2) >= 0; }
+bool ?<=?(const string_res & s1, const char* s2) { return strcmp(s1, s2) <= 0; }
+bool ?<? (const string_res & s1, const char* s2) { return strcmp(s1, s2) <  0; }
+
+int strcmp (const char* s1, const string_res & s2) {
     string_res s1x = s1;
-    return cmp(s1x, s2);
-}
-
-bool ?==?(const char* s1, const string_res &s2) { return cmp(s1, s2) == 0; }
-bool ?!=?(const char* s1, const string_res &s2) { return cmp(s1, s2) != 0; }
-bool ?>? (const char* s1, const string_res &s2) { return cmp(s1, s2) >  0; }
-bool ?>=?(const char* s1, const string_res &s2) { return cmp(s1, s2) >= 0; }
-bool ?<=?(const char* s1, const string_res &s2) { return cmp(s1, s2) <= 0; }
-bool ?<? (const char* s1, const string_res &s2) { return cmp(s1, s2) <  0; }
+    return strcmp(s1x, s2);
+}
+
+bool ?==?(const char* s1, const string_res & s2) { return strcmp(s1, s2) == 0; }
+bool ?!=?(const char* s1, const string_res & s2) { return strcmp(s1, s2) != 0; }
+bool ?>? (const char* s1, const string_res & s2) { return strcmp(s1, s2) >  0; }
+bool ?>=?(const char* s1, const string_res & s2) { return strcmp(s1, s2) >= 0; }
+bool ?<=?(const char* s1, const string_res & s2) { return strcmp(s1, s2) <= 0; }
+bool ?<? (const char* s1, const string_res & s2) { return strcmp(s1, s2) <  0; }
 
 
@@ -693,5 +688,5 @@
 // Search
 
-bool contains(const string_res &s, char ch) {
+bool contains(const string_res & s, char ch) {
     for ( i; size(s) ) {
         if (s[i] == ch) return true;
@@ -700,9 +695,9 @@
 }
 
-int find(const string_res &s, char search) {
+int find(const string_res & s, char search) {
     return findFrom(s, 0, search);
 }
 
-int findFrom(const string_res &s, size_t fromPos, char search) {
+int findFrom(const string_res & s, size_t fromPos, char search) {
     // FIXME: This paricular overload (find of single char) is optimized to use memchr.
     // The general overload (find of string, memchr applying to its first character) and `contains` should be adjusted to match.
@@ -715,24 +710,24 @@
 }
 
-int find(const string_res &s, const string_res &search) {
+int find(const string_res & s, const string_res & search) {
     return findFrom(s, 0, search);
 }
 
-int findFrom(const string_res &s, size_t fromPos, const string_res &search) {
+int findFrom(const string_res & s, size_t fromPos, const string_res & search) {
     return findFrom(s, fromPos, search.Handle.s, search.Handle.lnth);
 }
 
-int find(const string_res &s, const char* search) {
+int find(const string_res & s, const char* search) {
     return findFrom(s, 0, search);
 }
-int findFrom(const string_res &s, size_t fromPos, const char* search) {
+int findFrom(const string_res & s, size_t fromPos, const char* search) {
     return findFrom(s, fromPos, search, strlen(search));
 }
 
-int find(const string_res &s, const char* search, size_t searchsize) {
+int find(const string_res & s, const char* search, size_t searchsize) {
     return findFrom(s, 0, search, searchsize);
 }
 
-int findFrom(const string_res &s, size_t fromPos, const char* search, size_t searchsize) {
+int findFrom(const string_res & s, size_t fromPos, const char* search, size_t searchsize) {
 
     /* Remaining implementations essentially ported from Sunjay's work */
@@ -771,25 +766,25 @@
 }
 
-bool includes(const string_res &s, const string_res &search) {
+bool includes(const string_res & s, const string_res & search) {
     return includes(s, search.Handle.s, search.Handle.lnth);
 }
 
-bool includes(const string_res &s, const char* search) {
+bool includes(const string_res & s, const char* search) {
     return includes(s, search, strlen(search));
 }
 
-bool includes(const string_res &s, const char* search, size_t searchsize) {
+bool includes(const string_res & s, const char* search, size_t searchsize) {
     return find(s, search, searchsize) < s.Handle.lnth;
 }
 
-bool startsWith(const string_res &s, const string_res &prefix) {
+bool startsWith(const string_res & s, const string_res & prefix) {
     return startsWith(s, prefix.Handle.s, prefix.Handle.lnth);
 }
 
-bool startsWith(const string_res &s, const char* prefix) {
+bool startsWith(const string_res & s, const char* prefix) {
     return startsWith(s, prefix, strlen(prefix));
 }
 
-bool startsWith(const string_res &s, const char* prefix, size_t prefixsize) {
+bool startsWith(const string_res & s, const char* prefix, size_t prefixsize) {
     if (s.Handle.lnth < prefixsize) {
         return false;
@@ -798,13 +793,13 @@
 }
 
-bool endsWith(const string_res &s, const string_res &suffix) {
+bool endsWith(const string_res & s, const string_res & suffix) {
     return endsWith(s, suffix.Handle.s, suffix.Handle.lnth);
 }
 
-bool endsWith(const string_res &s, const char* suffix) {
+bool endsWith(const string_res & s, const char* suffix) {
     return endsWith(s, suffix, strlen(suffix));
 }
 
-bool endsWith(const string_res &s, const char* suffix, size_t suffixsize) {
+bool endsWith(const string_res & s, const char* suffix, size_t suffixsize) {
     if (s.Handle.lnth < suffixsize) {
         return false;
@@ -822,19 +817,19 @@
 // charclass, include, exclude
 
-void ?{}( charclass_res & this, const string_res & chars) {
-    (this){ chars.Handle.s, chars.Handle.lnth };
-}
-
-void ?{}( charclass_res & this, const char * chars ) {
-    (this){ chars, strlen(chars) };
-}
-
-void ?{}( charclass_res & this, const char * chars, size_t charssize ) {
-    (this.chars){ chars, charssize };
+void ?{}( charclass_res & s, const string_res & chars) {
+    (s){ chars.Handle.s, chars.Handle.lnth };
+}
+
+void ?{}( charclass_res & s, const char * chars ) {
+    (s){ chars, strlen(chars) };
+}
+
+void ?{}( charclass_res & s, const char * chars, size_t charssize ) {
+    (s.chars){ chars, charssize };
     // now sort it ?
 }
 
-void ^?{}( charclass_res & this ) {
-    ^(this.chars){};
+void ^?{}( charclass_res & s ) {
+    ^(s.chars){};
 }
 
@@ -844,5 +839,5 @@
 }
 
-int exclude(const string_res &s, const charclass_res &mask) {
+int exclude(const string_res & s, const charclass_res & mask) {
     for ( i; size(s) ) {
         if ( test(mask, s[i]) ) return i;
@@ -851,5 +846,5 @@
 }
 
-int include(const string_res &s, const charclass_res &mask) {
+int include(const string_res & s, const charclass_res & mask) {
     for ( i; size(s) ) {
         if ( ! test(mask, s[i]) ) return i;
@@ -863,15 +858,15 @@
 // Add a new HandleNode node n after the current HandleNode node.
 
-static void AddThisAfter( HandleNode & this, HandleNode & n ) with(this) {
-#ifdef VbyteDebug
-    serr | "enter:AddThisAfter, this:" | &this | " n:" | &n;
+static void AddThisAfter( HandleNode & s, HandleNode & n ) with(s) {
+#ifdef VbyteDebug
+    serr | "enter:AddThisAfter, s:" | &s | " n:" | &n;
 #endif // VbyteDebug
     // Performance note: we are on the critical path here. MB has ensured that the verifies don't contribute to runtime (are compiled away, like they're supposed to be).
     verify( n.ulink != 0p );
-    verify( this.ulink == n.ulink );
+    verify( s.ulink == n.ulink );
     flink = n.flink;
     blink = &n;
-    n.flink->blink = &this;
-    n.flink = &this;
+    n.flink->blink = &s;
+    n.flink = &s;
 #ifdef VbyteDebug
     {
@@ -894,7 +889,7 @@
 // Delete the current HandleNode node.
 
-static void DeleteNode( HandleNode & this ) with(this) {
-#ifdef VbyteDebug
-    serr | "enter:DeleteNode, this:" | &this;
+static void DeleteNode( HandleNode & s ) with(s) {
+#ifdef VbyteDebug
+    serr | "enter:DeleteNode, s:" | &s;
 #endif // VbyteDebug
     flink->blink = blink;
@@ -906,9 +901,8 @@
 
 
-
 // Allocates specified storage for a string from byte-string area. If not enough space remains to perform the
 // allocation, the garbage collection routine is called.
 
-static char * VbyteAlloc( VbyteHeap & this, int size ) with(this) {
+static char * VbyteAlloc( VbyteHeap & s, int size ) with(s) {
 #ifdef VbyteDebug
     serr | "enter:VbyteAlloc, size:" | size;
@@ -918,6 +912,6 @@
 
     NoBytes = ( uintptr_t )EndVbyte + size;
-    if ( NoBytes > ( uintptr_t )ExtVbyte ) {		// enough room for new byte-string ?
-		garbage( this, size );					// firer up the garbage collector
+    if ( NoBytes > ( uintptr_t )ExtVbyte ) {			// enough room for new byte-string ?
+		garbage( s, size );								// firer up the garbage collector
 		verify( (( uintptr_t )EndVbyte + size) <= ( uintptr_t )ExtVbyte  && "garbage run did not free up required space" );
     } // if
@@ -939,6 +933,5 @@
 // VbyteAlloc to claim the new space, while doing optimal copying from old to new, then free old.
 
-static char * VbyteTryAdjustLast( VbyteHeap & this, int delta ) with(this) {
-
+static char * VbyteTryAdjustLast( VbyteHeap & s, int delta ) with(s) {
     if ( ( uintptr_t )EndVbyte + delta <= ( uintptr_t )ExtVbyte ) {
         // room available
@@ -961,10 +954,10 @@
 // the address in the byte string area.
 
-static void MoveThisAfter( HandleNode & this, const HandleNode  & h ) with(this) {
-#ifdef VbyteDebug
-    serr | "enter:MoveThisAfter, this:" | & this | " h:" | & h;
+static void MoveThisAfter( HandleNode & s, const HandleNode  & h ) with(s) {
+#ifdef VbyteDebug
+    serr | "enter:MoveThisAfter, s:" | & s | " h:" | & h;
 #endif // VbyteDebug
     verify( h.ulink != 0p );
-    verify( this.ulink == h.ulink );
+    verify( s.ulink == h.ulink );
     if ( s < h.s ) {					// check argument values
 		// serr | "VbyteSM: Error - Cannot move byte string starting at:" | s | " after byte string starting at:"
@@ -976,7 +969,7 @@
     HandleNode *i;
     for ( i = h.flink; i->s != 0 && s > ( i->s ); i = i->flink ); // find the position for this node after h
-    if ( & this != i->blink ) {
-		DeleteNode( this );
-		AddThisAfter( this, *i->blink );
+    if ( & s != i->blink ) {
+		DeleteNode( s );
+		AddThisAfter( s, *i->blink );
     } // if
 #ifdef VbyteDebug
@@ -1058,5 +1051,5 @@
 // the containing string has been moved. Hence, they only require that their string pointers be adjusted.
 
-void compaction(VbyteHeap & this) with(this) {
+void compaction(VbyteHeap & s) with(s) {
     HandleNode *h;
     char *obase, *nbase, *limit;
@@ -1098,5 +1091,5 @@
 // the heap.  The heap is then compacted in the existing heap or into the newly allocated heap.
 
-void garbage(VbyteHeap & this, int minreq ) with(this) {
+void garbage(VbyteHeap & s, int minreq ) with(s) {
 #ifdef VbyteDebug
     serr | "enter:garbage";
@@ -1124,5 +1117,5 @@
     if ( ( double ) AmountFree < ( CurrSize * heap_expansion_freespace_threshold ) || AmountFree < minreq ) {	// free space less than threshold or not enough to serve cur request
 
-		extend( this, max( CurrSize, minreq ) );				// extend the heap
+		extend( s, max( CurrSize, minreq ) );				// extend the heap
 
 			//  Peter says, "This needs work before it should be used."
@@ -1133,5 +1126,5 @@
 
     } else {
-        compaction(this);					// in-place
+        compaction(s);					// in-place
     }// if
 #ifdef VbyteDebug
@@ -1159,5 +1152,5 @@
 // area is deleted.
 
-void extend( VbyteHeap & this, int size ) with (this) {
+void extend( VbyteHeap & s, int size ) with (s) {
 #ifdef VbyteDebug
     serr | "enter:extend, size:" | size;
@@ -1171,5 +1164,5 @@
     StartVbyte = EndVbyte = TEMP_ALLOC(char, CurrSize);
     ExtVbyte = (void *)( StartVbyte + CurrSize );
-    compaction(this);					// copy from old heap to new & adjust pointers to new heap
+    compaction(s);					// copy from old heap to new & adjust pointers to new heap
     free( OldStartVbyte );				// release old heap
 #ifdef VbyteDebug
Index: libcfa/src/collections/string_res.hfa
===================================================================
--- libcfa/src/collections/string_res.hfa	(revision 8b4faf639e449fe289d559f0202fd6e97f96d2d3)
+++ libcfa/src/collections/string_res.hfa	(revision 681e12fe6a6c02c012774ae0c71d29db74b18307)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Aug 12 15:45:47 2023
-// Update Count     : 2
+// Last Modified On : Thu Jan  4 11:28:06 2024
+// Update Count     : 27
 //
 
@@ -70,37 +70,37 @@
 
 // Getters
-size_t size(const string_res &s);
+size_t size(const string_res & s);
 
 // Constructors, Assignment Operators, Destructor
-void ?{}(string_res &s); // empty string
-void ?{}(string_res &s, const char* buffer, size_t bsize); // copy specific length from buffer
-static inline void ?{}(string_res &s, const char* rhs) { // copy from string literal (NULL-terminated)
+void ?{}(string_res & s); // empty string
+void ?{}(string_res & s, const char * buffer, size_t bsize); // copy specific length from buffer
+static inline void ?{}(string_res & s, const char * rhs) { // copy from string literal (NULL-terminated)
     (s){ rhs, strlen(rhs) };
 }
 
-void ?{}(string_res &s, const string_res & s2) = void;
-void ?{}(string_res &s, string_res & s2) = void;
+void ?{}(string_res & s, const string_res & s2) = void;
+void ?{}(string_res & s, string_res & s2) = void;
 
 enum StrResInitMode { COPY_VALUE, SHARE_EDITS };
-void ?{}(string_res &s, const string_res & src, StrResInitMode, size_t start, size_t end );
-static inline void ?{}(string_res &s, const string_res & src, StrResInitMode mode ) {
+void ?{}(string_res & s, const string_res & src, StrResInitMode, size_t start, size_t end );
+static inline void ?{}(string_res & s, const string_res & src, StrResInitMode mode ) {
     ?{}( s, src, mode, 0, size(src));
 }
 
-string_res & assign(string_res &s, const char* buffer, size_t bsize); // copy specific length from buffer
-static inline string_res & ?=?(string_res &s, const char* other) {  // copy from string literal (NULL-terminated)
-    return assign(s, other, strlen(other));
-}
-string_res & ?=?(string_res &s, const string_res &other);
-string_res & ?=?(string_res &s, string_res &other);
-string_res & ?=?(string_res &s, char other);
-
-void ^?{}(string_res &s);
+string_res & assign(string_res & s, const char * buffer, size_t bsize); // copy specific length from buffer
+static inline string_res & ?=?(string_res & s, const char * c) {  // copy from string literal (NULL-terminated)
+    return assign(s, c, strlen(c));
+}
+string_res & ?=?(string_res & s, const string_res & c);
+string_res & ?=?(string_res & s, string_res & c);
+string_res & ?=?(string_res & s, char c);
+
+void ^?{}(string_res & s);
 
 // IO Operator
-ofstream & ?|?(ofstream &out, const string_res &s);
-void ?|?(ofstream &out, const string_res &s);
-ifstream & ?|?(ifstream &in, string_res &s);
-void ?|?( ifstream & in, string_res & this );
+ofstream & ?|?(ofstream & out, const string_res & s);
+void ?|?(ofstream & out, const string_res & s);
+ifstream & ?|?(ifstream & in, string_res & s);
+void ?|?( ifstream & in, string_res & s );
 
 struct _Istream_Rstr {
@@ -113,8 +113,8 @@
 	_Istream_Rstr wdi( unsigned int rwd, string_res & s ) { return (_Istream_Rstr)@{ &s, {{0p}, rwd, {.flags.rwd : true}} }; }
 	_Istream_Rstr getline( string_res & s, const char delimiter = '\n' ) {
-		return (_Istream_Rstr)@{ &s, {{.delimiter : { delimiter, '\0' } }, -1, {.flags.delimiter : true, .flags.inex : true}} };
+		return (_Istream_Rstr)@{ &s, {{.delimiters : { delimiter, '\0' } }, -1, {.flags.delimiter : true, .flags.inex : true}} };
 	}
 	_Istream_Rstr & getline( _Istream_Rstr & fmt, const char delimiter = '\n' ) {
-		fmt.delimiter[0] = delimiter; fmt.delimiter[1] = '\0'; fmt.flags.delimiter = true; fmt.flags.inex = true; return fmt;
+		fmt.delimiters[0] = delimiter; fmt.delimiters[1] = '\0'; fmt.flags.delimiter = true; fmt.flags.inex = true; return fmt;
 	}
 	_Istream_Rstr incl( const char scanset[], string_res & s ) { return (_Istream_Rstr)@{ &s, {{scanset}, -1, {.flags.inex : false}} }; }
@@ -129,18 +129,18 @@
 
 // Concatenation
-void append(string_res &s, const char* buffer, size_t bsize);
-void ?+=?(string_res &s, char other); // append a character
-void ?+=?(string_res &s, const string_res &s2); // append-concatenate to first string
-static inline void ?+=?(string_res &s, const char* other) {
-    append( s, other, strlen(other) );
+void append(string_res & s, const char * buffer, size_t bsize);
+void ?+=?(string_res & s, char c); // append a character
+void ?+=?(string_res & s, const string_res & s2); // append-concatenate to first string
+static inline void ?+=?(string_res & s, const char * c) {
+    append( s, c, strlen(c) );
 }
 
 // Character access
-void assignAt(const string_res &s, size_t index, char val);
-char ?[?](const string_res &s, size_t index); // Mike changed to ret by val from Sunjay's ref, to match Peter's
-//char codePointAt(const string_res &s, size_t index); // revisit under Unicode
+void assignAt(const string_res & s, size_t index, char val);
+char ?[?](const string_res & s, size_t index); // Mike changed to ret by val from Sunjay's ref, to match Peter's
+//char codePointAt(const string_res & s, size_t index); // revisit under Unicode
 
 // Comparisons
-int  cmp (const string_res &, const string_res &);
+int  strcmp (const string_res &, const string_res &);
 bool ?==?(const string_res &, const string_res &);
 bool ?!=?(const string_res &, const string_res &);
@@ -150,52 +150,52 @@
 bool ?<? (const string_res &, const string_res &);
 
-int  cmp (const string_res &, const char*);
-bool ?==?(const string_res &, const char*);
-bool ?!=?(const string_res &, const char*);
-bool ?>? (const string_res &, const char*);
-bool ?>=?(const string_res &, const char*);
-bool ?<=?(const string_res &, const char*);
-bool ?<? (const string_res &, const char*);
-
-int  cmp (const char*, const string_res &);
-bool ?==?(const char*, const string_res &);
-bool ?!=?(const char*, const string_res &);
-bool ?>? (const char*, const string_res &);
-bool ?>=?(const char*, const string_res &);
-bool ?<=?(const char*, const string_res &);
-bool ?<? (const char*, const string_res &);
+int  strcmp(const string_res &, const char *);
+bool ?==?(const string_res &, const char *);
+bool ?!=?(const string_res &, const char *);
+bool ?>? (const string_res &, const char *);
+bool ?>=?(const string_res &, const char *);
+bool ?<=?(const string_res &, const char *);
+bool ?<? (const string_res &, const char *);
+
+int  strcmp(const char *, const string_res &);
+bool ?==?(const char *, const string_res &);
+bool ?!=?(const char *, const string_res &);
+bool ?>? (const char *, const string_res &);
+bool ?>=?(const char *, const string_res &);
+bool ?<=?(const char *, const string_res &);
+bool ?<? (const char *, const string_res &);
 
 // String search
-bool contains(const string_res &s, char ch); // single character
-
-int find(const string_res &s, char search);
-int find(const string_res &s, const string_res &search);
-int find(const string_res &s, const char* search);
-int find(const string_res &s, const char* search, size_t searchsize);
-
-int findFrom(const string_res &s, size_t fromPos, char search);
-int findFrom(const string_res &s, size_t fromPos, const string_res &search);
-int findFrom(const string_res &s, size_t fromPos, const char* search);
-int findFrom(const string_res &s, size_t fromPos, const char* search, size_t searchsize);
-
-bool includes(const string_res &s, const string_res &search);
-bool includes(const string_res &s, const char* search);
-bool includes(const string_res &s, const char* search, size_t searchsize);
-
-bool startsWith(const string_res &s, const string_res &prefix);
-bool startsWith(const string_res &s, const char* prefix);
-bool startsWith(const string_res &s, const char* prefix, size_t prefixsize);
-
-bool endsWith(const string_res &s, const string_res &suffix);
-bool endsWith(const string_res &s, const char* suffix);
-bool endsWith(const string_res &s, const char* suffix, size_t suffixsize);
-
-int include(const string_res &s, const charclass_res &mask);
-int exclude(const string_res &s, const charclass_res &mask);
+bool contains(const string_res & s, char ch); // single character
+
+int find(const string_res & s, char search);
+int find(const string_res & s, const string_res & search);
+int find(const string_res & s, const char * search);
+int find(const string_res & s, const char * search, size_t searchsize);
+
+int findFrom(const string_res & s, size_t fromPos, char search);
+int findFrom(const string_res & s, size_t fromPos, const string_res & search);
+int findFrom(const string_res & s, size_t fromPos, const char * search);
+int findFrom(const string_res & s, size_t fromPos, const char * search, size_t searchsize);
+
+bool includes(const string_res & s, const string_res & search);
+bool includes(const string_res & s, const char * search);
+bool includes(const string_res & s, const char * search, size_t searchsize);
+
+bool startsWith(const string_res & s, const string_res & prefix);
+bool startsWith(const string_res & s, const char * prefix);
+bool startsWith(const string_res & s, const char * prefix, size_t prefixsize);
+
+bool endsWith(const string_res & s, const string_res & suffix);
+bool endsWith(const string_res & s, const char * suffix);
+bool endsWith(const string_res & s, const char * suffix, size_t suffixsize);
+
+int include(const string_res & s, const charclass_res & mask);
+int exclude(const string_res & s, const charclass_res & mask);
 
 // Modifiers
-void padStart(string_res &s, size_t n);
-void padStart(string_res &s, size_t n, char padding);
-void padEnd(string_res &s, size_t n);
+void padStart(string_res & s, size_t n);
+void padStart(string_res & s, size_t n, char padding);
+void padEnd(string_res & s, size_t n);
 void padEnd(string_res &s, size_t n, char padding);
 
