Index: libcfa/src/containers/string_res.cfa
===================================================================
--- libcfa/src/containers/string_res.cfa	(revision 2b303702c0215c73cc25f072af9d55d8ca0991a0)
+++ libcfa/src/containers/string_res.cfa	(revision 4e8df745bf32da07b36eb0f151a7206260a7d2eb)
@@ -18,5 +18,4 @@
 
 #include <stdlib.hfa>  // e.g. malloc
-#include <string.h>    // e.g. strlen
 #include <assert.h>
 
@@ -43,24 +42,24 @@
 
     
-static inline void compaction( VbyteHeap & );				// compaction of the byte area
-static inline void garbage( VbyteHeap &, int );				// garbage collect the byte area
-static inline void extend( VbyteHeap &, int );			// extend the size of the byte area
-static inline void reduce( VbyteHeap &, int );			// reduce the size of the byte area
-
-static inline void ?{}( VbyteHeap &, size_t = 1000 );
-static inline void ^?{}( VbyteHeap & );
-static inline void ByteCopy( char *, int, int, char *, int, int ); // copy a block of bytes from one location in the heap to another
-static inline int ByteCmp( char *, int, int, char *, int, int );	// compare 2 blocks of bytes
-static inline char *VbyteAlloc( VbyteHeap &, int );			// allocate a block bytes in the heap
-static inline char *VbyteTryAdjustLast( VbyteHeap &, int );
-
-static inline void AddThisAfter( HandleNode &, HandleNode & );
-static inline void DeleteNode( HandleNode & );
-static inline void MoveThisAfter( HandleNode &, const HandleNode & );		// move current handle after parameter handle
+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
+
+static void ?{}( VbyteHeap &, size_t = 1000 );
+static void ^?{}( VbyteHeap & );
+static void ByteCopy( char *, int, int, char *, int, int ); // copy a block of bytes from one location in the heap to another
+static int ByteCmp( char *, int, int, char *, int, int );	// compare 2 blocks of bytes
+static char *VbyteAlloc( VbyteHeap &, int );			// allocate a block bytes in the heap
+static char *VbyteTryAdjustLast( VbyteHeap &, int );
+
+static void AddThisAfter( HandleNode &, HandleNode & );
+static void DeleteNode( HandleNode & );
+static void MoveThisAfter( HandleNode &, const HandleNode & );		// move current handle after parameter handle
 
 
 // Allocate the storage for the variable sized area and intialize the heap variables.
 
-static inline void ?{}( VbyteHeap & this, size_t Size ) with(this) {
+static void ?{}( VbyteHeap & this, size_t Size ) with(this) {
 #ifdef VbyteDebug
     serr | "enter:VbyteHeap::VbyteHeap, this:" | &this | " Size:" | Size;
@@ -81,5 +80,5 @@
 // Release the dynamically allocated storage for the byte area.
 
-static inline void ^?{}( VbyteHeap & this ) with(this) {
+static void ^?{}( VbyteHeap & this ) with(this) {
     free( StartVbyte );
 } // ~VbyteHeap
@@ -92,5 +91,5 @@
 // creator.
 
-static inline void ?{}( HandleNode & this ) with(this) {
+static void ?{}( HandleNode & this ) with(this) {
 #ifdef VbyteDebug
     serr | "enter:HandleNode::HandleNode, this:" | &this;
@@ -107,5 +106,5 @@
 // collection.
 
-static inline void ?{}( HandleNode & this, VbyteHeap & vh ) with(this) {
+static void ?{}( HandleNode & this, VbyteHeap & vh ) with(this) {
 #ifdef VbyteDebug
     serr | "enter:HandleNode::HandleNode, this:" | &this;
@@ -124,5 +123,5 @@
 // is the responsibility of the creator to destroy it.
 
-static inline void ^?{}( HandleNode & this ) with(this) {
+static void ^?{}( HandleNode & this ) with(this) {
 #ifdef VbyteDebug
     serr | "enter:HandleNode::~HandleNode, this:" | & this;
@@ -237,5 +236,5 @@
 }
 
-static inline 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 };
@@ -257,9 +256,4 @@
 void ?{}(string_res &s, const char* rhs, size_t rhslnth) with(s) {
     eagerCopyCtorHelper(s, rhs, rhslnth);
-}
-
-// String literal constructor
-void ?{}(string_res &s, const char* rhs) {
-    (s){ rhs, strlen(rhs) };
 }
 
@@ -490,8 +484,4 @@
 }
 
-void ?=?(string_res &s, const char* other) {
-    assign(s, other, strlen(other));
-}
-
 void ?=?(string_res &s, char other) {
     assign(s, &other, 1);
@@ -543,9 +533,9 @@
 
 void append(string_res &str1, const char * buffer, size_t bsize) {
-    size_t clnth = size(str1) + bsize;
-    if ( str1.Handle.s + size(str1) == buffer ) { // already juxtapose ?
+    size_t clnth = str1.Handle.lnth + bsize;
+    if ( str1.Handle.s + str1.Handle.lnth == buffer ) { // already juxtapose ?
         // no-op
     } else {						// must copy some text
-        if ( str1.Handle.s + size(str1) == VbyteAlloc(*str1.Handle.ulink, 0) ) { // str1 at end of string area ?
+        if ( str1.Handle.s + str1.Handle.lnth == VbyteAlloc(*str1.Handle.ulink, 0) ) { // str1 at end of string area ?
             VbyteAlloc( *str1.Handle.ulink, bsize ); // create room for 2nd part at the end of string area
         } else {					// copy the two parts
@@ -553,8 +543,7 @@
             char * str1oldBuf = str1.Handle.s;  // must read after VbyteAlloc call in case it gs's
             str1.Handle.s = str1newBuf;
-            ByteCopy( str1.Handle.s, 0, str1.Handle.lnth, str1oldBuf, 0, str1.Handle.lnth);
+            memcpy( str1.Handle.s, str1oldBuf,  str1.Handle.lnth );
         } // if
-        ByteCopy( str1.Handle.s, str1.Handle.lnth, bsize, (char*)buffer, 0, (int)bsize);
-        //       VbyteHeap & this, char *Dst, int DstStart, int DstLnth, char *Src, int SrcStart, int SrcLnth 
+        memcpy( str1.Handle.s + str1.Handle.lnth, buffer, bsize );
     } // if
     str1.Handle.lnth = clnth;
@@ -569,7 +558,4 @@
 }
 
-void ?+=?(string_res &s, const char* other) {
-    append( s, other, strlen(other) );
-}
 
 
@@ -748,5 +734,5 @@
 // Add a new HandleNode node n after the current HandleNode node.
 
-static inline void AddThisAfter( HandleNode & this, HandleNode & n ) with(this) {
+static void AddThisAfter( HandleNode & this, HandleNode & n ) with(this) {
 #ifdef VbyteDebug
     serr | "enter:AddThisAfter, this:" | &this | " n:" | &n;
@@ -778,5 +764,5 @@
 // Delete the current HandleNode node.
 
-static inline void DeleteNode( HandleNode & this ) with(this) {
+static void DeleteNode( HandleNode & this ) with(this) {
 #ifdef VbyteDebug
     serr | "enter:DeleteNode, this:" | &this;
@@ -794,5 +780,5 @@
 // allocation, the garbage collection routine is called.
 
-static inline char * VbyteAlloc( VbyteHeap & this, int size ) with(this) {
+static char * __attribute__((noinline)) VbyteAlloc( VbyteHeap & this, int size ) with(this) {
 #ifdef VbyteDebug
     serr | "enter:VbyteAlloc, size:" | size;
@@ -804,8 +790,5 @@
     if ( NoBytes > ( uintptr_t )ExtVbyte ) {		// enough room for new byte-string ?
 		garbage( this, size );					// firer up the garbage collector
-		NoBytes = ( uintptr_t )EndVbyte + size;		// try again
-		if ( NoBytes > ( uintptr_t )ExtVbyte ) {	// enough room for new byte-string ?
-            assert( 0 && "garbage run did not free up required space" );
-		} // if
+		verify( (( uintptr_t )EndVbyte + size) <= ( uintptr_t )ExtVbyte  && "garbage run did not free up required space" );
     } // if
     r = EndVbyte;
@@ -826,5 +809,5 @@
 // VbyteAlloc to claim the new space, while doing optimal copying from old to new, then free old.
 
-static inline char * VbyteTryAdjustLast( VbyteHeap & this, int delta ) with(this) {
+static char * VbyteTryAdjustLast( VbyteHeap & this, int delta ) with(this) {
 
     if ( ( uintptr_t )EndVbyte + delta <= ( uintptr_t )ExtVbyte ) {
@@ -848,5 +831,5 @@
 // the address in the byte string area.
 
-static inline void MoveThisAfter( HandleNode & this, const HandleNode  & h ) with(this) {
+static void MoveThisAfter( HandleNode & this, const HandleNode  & h ) with(this) {
 #ifdef VbyteDebug
     serr | "enter:MoveThisAfter, this:" | & this | " h:" | & h;
Index: libcfa/src/containers/string_res.hfa
===================================================================
--- libcfa/src/containers/string_res.hfa	(revision 2b303702c0215c73cc25f072af9d55d8ca0991a0)
+++ libcfa/src/containers/string_res.hfa	(revision 4e8df745bf32da07b36eb0f151a7206260a7d2eb)
@@ -17,4 +17,5 @@
 
 #include <fstream.hfa>
+#include <string.h>    // e.g. strlen
 
     
@@ -72,6 +73,8 @@
 // Constructors, Assignment Operators, Destructor
 void ?{}(string_res &s); // empty string
-void ?{}(string_res &s, const char* initial); // copy from string literal (NULL-terminated)
 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;
@@ -85,5 +88,7 @@
 
 void assign(string_res &s, const char* buffer, size_t bsize); // copy specific length from buffer
-void ?=?(string_res &s, const char* other); // copy from string literal (NULL-terminated)
+static inline void ?=?(string_res &s, const char* other) {  // copy from string literal (NULL-terminated)
+    assign(s, other, strlen(other));
+}
 void ?=?(string_res &s, const string_res &other);
 void ?=?(string_res &s, string_res &other);
@@ -97,8 +102,10 @@
 
 // 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
-void ?+=?(string_res &s, const char* other);
-void append(string_res &s, const char* buffer, size_t bsize);
+static inline void ?+=?(string_res &s, const char* other) {
+    append( s, other, strlen(other) );
+}
 
 // Character access