Index: libcfa/src/containers/string_res.cfa
===================================================================
--- libcfa/src/containers/string_res.cfa	(revision f93c50af1293992245e177607785a3b5c96800c1)
+++ libcfa/src/containers/string_res.cfa	(revision 218096fb228f5c7862385d7645097bffddd90c17)
@@ -17,4 +17,5 @@
 #include <stdlib.hfa>  // e.g. malloc
 #include <string.h>    // e.g. strlen
+#include <assert.h>
 
 //######################### VbyteHeap "header" #########################
@@ -102,5 +103,5 @@
 // creator.
 
-void ?{}( HandleNode & this ) with(this) {
+static inline void ?{}( HandleNode & this ) with(this) {
 #ifdef VbyteDebug
     serr | "enter:HandleNode::HandleNode, this:" | &this;
@@ -117,5 +118,5 @@
 // collection.
 
-void ?{}( HandleNode & this, VbyteHeap & vh ) with(this) {
+static inline void ?{}( HandleNode & this, VbyteHeap & vh ) with(this) {
 #ifdef VbyteDebug
     serr | "enter:HandleNode::HandleNode, this:" | &this;
@@ -133,5 +134,5 @@
 // is the responsibility of the creator to destroy it.
 
-void ^?{}( HandleNode & this ) with(this) {
+static inline void ^?{}( HandleNode & this ) with(this) {
 #ifdef VbyteDebug
     serr | "enter:HandleNode::~HandleNode, this:" | & this;
@@ -223,8 +224,10 @@
 void ?{}(string_res &s, const string_res & s2, StrResInitMode mode, size_t start, size_t end ) {
 
-    (s.Handle){ HeapArea };
+    verify( start <= end && end <= s2.Handle.lnth );
+
+    (s.Handle){};
     s.Handle.s = s2.Handle.s + start;
     s.Handle.lnth = end - start;
-    MoveThisAfter(s.Handle, s2.Handle );			// insert this handle after rhs handle
+    AddThisAfter(s.Handle, s2.Handle );			// insert this handle after rhs handle
     // ^ bug?  skip others at early point in string
     
@@ -234,5 +237,5 @@
         s.shareEditSet_next = &s;
     } else {
-        assert( mode == SHARE_EDITS );
+        verify( mode == SHARE_EDITS );
 
         // s2 is logically const but not implementation const
@@ -297,8 +300,8 @@
     char *limit = pasting.Handle.s + pasting.Handle.lnth;
     for (string_res * p = this.shareEditSet_next; p != &this; p = p->shareEditSet_next) {
-        assert (p->Handle.s >= beforeBegin);
+        verify (p->Handle.s >= beforeBegin);
         if ( p->Handle.s >= afterBegin ) {
-            assert ( p->Handle.s <= afterBegin + afterLen );
-            assert ( p->Handle.s + p->Handle.lnth <= afterBegin + afterLen );
+            verify ( p->Handle.s <= afterBegin + afterLen );
+            verify ( p->Handle.s + p->Handle.lnth <= afterBegin + afterLen );
             // p starts after the edit
             // take start and end as end-anchored
@@ -318,5 +321,5 @@
             } else {
                 // p ends after the edit
-                assert ( p->Handle.s + p->Handle.lnth <= afterBegin + afterLen );
+                verify ( p->Handle.s + p->Handle.lnth <= afterBegin + afterLen );
                 // take end as end-anchored
                 // stretch-shrink p according to the edit
@@ -328,7 +331,7 @@
             p->Handle.s = pasting.Handle.s + startOffsetFromStart;
         } else {
-            assert ( p->Handle.s < afterBegin );
+            verify ( p->Handle.s < afterBegin );
             // p starts during the edit
-            assert( p->Handle.s + p->Handle.lnth >= beforeBegin + beforeLen );
+            verify( p->Handle.s + p->Handle.lnth >= beforeBegin + beforeLen );
             if ( p->Handle.s + p->Handle.lnth < afterBegin ) {
                 // p ends during the edit; p does not include the last character replaced
@@ -374,6 +377,6 @@
     s.shareEditSet_prev->shareEditSet_next = s.shareEditSet_next;
     s.shareEditSet_next->shareEditSet_prev = s.shareEditSet_prev;
-    s.shareEditSet_next = &s;
-    s.shareEditSet_prev = &s;
+    // s.shareEditSet_next = &s;
+    // s.shareEditSet_prev = &s;
 }
 
@@ -385,4 +388,9 @@
     //TODO: Check if index is valid (no exceptions yet)
     return Handle.s[index];
+}
+
+void assignAt(const string_res &s, size_t index, char val) {
+    string_res editZone = { s, SHARE_EDITS, index, index+1 };
+    assign(editZone, &val, 1);
 }
 
@@ -653,4 +661,5 @@
 		NoBytes = ( uintptr_t )EndVbyte + size;		// try again
 		if ( NoBytes > ( uintptr_t )ExtVbyte ) {	// enough room for new byte-string ?
+// unimplemented feature - assert, not verify
 assert( 0 && "need to implement actual growth" );
 			// extend( size );				// extend the byte-string area
@@ -677,5 +686,5 @@
 		//      | ( h->s ) | " and keep handles in ascending order";
 		// exit(-1 );
-		assert( 0 && "VbyteSM: Error - Cannot move byte strings as requested and keep handles in ascending order");
+		verify( 0 && "VbyteSM: Error - Cannot move byte strings as requested and keep handles in ascending order");
     } // if
 
@@ -839,4 +848,5 @@
     if ( AmountFree < ( int )( CurrSize * 0.1 )) {	// free space less than 10% ?
 
+// unimplemented feature - assert, not verify
 assert( 0 && "need to implement actual growth" );
 //		extend( CurrSize );				// extend the heap
Index: libcfa/src/containers/string_res.hfa
===================================================================
--- libcfa/src/containers/string_res.hfa	(revision f93c50af1293992245e177607785a3b5c96800c1)
+++ libcfa/src/containers/string_res.hfa	(revision 218096fb228f5c7862385d7645097bffddd90c17)
@@ -31,9 +31,4 @@
     unsigned int lnth;					// length of byte string
 }; // HandleNode
-
-void ?{}( HandleNode & );			// constructor for header node
-
-void ?{}( HandleNode &, VbyteHeap & );		// constructor for nodes in the handle list
-void ^?{}( HandleNode & );			// destructor for handle nodes
 
 extern VbyteHeap * DEBUG_string_heap;
@@ -105,4 +100,5 @@
 
 // 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