Changeset d8d512e for libcfa/src/containers

Timestamp:

Sep 8, 2021, 4:40:08 PM (3 years ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

5a40e4e

Parents:

f26923e

Message:

Reorganizing string constructor/assignment overload calls for better performance.

Location:

libcfa/src/containers

Files:

• string_res.cfa (modified) (7 diffs)
• string_res.hfa (modified) (2 diffs)

libcfa/src/containers/string_res.cfa

@@ -223 +223 @@
 }
 
-void ?=?(string_res &s, const char* other) {
-    string_res sother = other;
-    const string_res & sother_ref = sother; 
-    s = sother_ref;  // `s = sother` calls autogen ?=?
-}
-
-void ?=?(string_res &s, char other) {
-    char otherCstr[2] = {other, 0};
-    s = otherCstr;
-}
-
-// Copy assignment operator
-void ?=?(string_res & this, const string_res & rhs) with( this ) {
+void assign(string_res &this, const char* buffer, size_t bsize) {
 
     char * afterBegin = this.Handle.s + this.Handle.lnth;
@@ -251 +239 @@
 
     string_res pasting = { beforeBegin, beforeLen };
-    pasting += rhs;
+    append(pasting, buffer, bsize);
     string_res after = { afterBegin, afterLen }; // juxtaposed with in-progress pasting
     pasting += after;                        // optimized case
@@ -258 +246 @@
 
     this.Handle.s = pasting.Handle.s + beforeLen;
-    this.Handle.lnth = rhs.Handle.lnth;
+    this.Handle.lnth = bsize;
     MoveThisAfter( this.Handle, pasting.Handle );
 
@@ -314 +302 @@
 }
 
+void ?=?(string_res &s, const char* other) {
+    assign(s, other, strlen(other));
+}
+
+void ?=?(string_res &s, char other) {
+    assign(s, &other, 1);
+}
+
+// Copy assignment operator
+void ?=?(string_res & this, const string_res & rhs) with( this ) {
+    assign(this, rhs.Handle.s, rhs.Handle.lnth);
+}
+
 void ?=?(string_res & this, string_res & rhs) with( this ) {
     const string_res & rhs2 = rhs;
@@ -340 +341 @@
 }
 
+
 ///////////////////////////////////////////////////////////////////
-// Slice-Concatenate helper
-
-void append(string_res &str1, const string_res & str_src, size_t start, size_t end) {
-    size_t clnth = size(str1) + end - start;
-    if ( str1.Handle.s + size(str1) == str_src.Handle.s && start == 0) { // already juxtapose ?
+// Concatenation
+
+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 ?
+        // no-op
     } else {                                            // must copy some text
         if ( str1.Handle.s + size(str1) == VbyteAlloc(HeapArea, 0) ) { // str1 at end of string area ?
-            VbyteAlloc(HeapArea, end - start); // create room for 2nd part at the end of string area
+            VbyteAlloc(HeapArea, bsize); // create room for 2nd part at the end of string area
         } else {                                        // copy the two parts
             char * str1oldBuf = str1.Handle.s;
@@ -354 +357 @@
             ByteCopy( HeapArea, str1.Handle.s, 0, str1.Handle.lnth, str1oldBuf, 0, str1.Handle.lnth);
         } // if
-        ByteCopy( HeapArea, str1.Handle.s, str1.Handle.lnth, str_src.Handle.lnth, str_src.Handle.s, start, end);
+        ByteCopy( HeapArea, 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 
     } // if
@@ -360 +363 @@
 }
 
-
-
-///////////////////////////////////////////////////////////////////
-// Concatenation
-
 void ?+=?(string_res &str1, const string_res &str2) {
-    append( str1, str2, 0, size(str2) );
+    append( str1, str2.Handle.s, str2.Handle.lnth );
 }
 
 void ?+=?(string_res &s, char other) {
-    string_res other_s = { &other, 1 };
-    s += other_s;
+    append( s, &other, 1 );
 }
 
 void ?+=?(string_res &s, const char* other) {
-    string_res other_s = other;
-    s += other_s;
+    append( s, other, strlen(other) );
 }
 

libcfa/src/containers/string_res.hfa

@@ -82 +82 @@
 }
 
-void ?=?(string_res &s, const char* other); // copy assignment from literal
+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)
 void ?=?(string_res &s, const string_res &other);
 void ?=?(string_res &s, string_res &other);
-void ?=?(string_res &s, char other);  // Str tolerates memcpys; still saw calls to autogen 
+void ?=?(string_res &s, char other);
 
 void ^?{}(string_res &s);
@@ -96 +97 @@
 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); // append-concatenate to first string
+void ?+=?(string_res &s, const char* other);
+void append(string_res &s, const char* buffer, size_t bsize);
 
 // Character access