Changeset fe18b46 for libcfa/src/containers

Timestamp:

Oct 19, 2021, 2:55:36 PM (3 years ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum

Children:

0ca15b7

Parents:

6f7aff3

Message:

String hybrid testing and fixing no-share version through the api-coverage case

File:

• libcfa/src/containers/string_res.cfa (modified) (7 diffs)

libcfa/src/containers/string_res.cfa

@@ -258 +258 @@
 }
 
+// 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) {
+    (Handle){ heap };
+    Handle.s = VbyteAlloc(*Handle.ulink, rhslnth);
+    Handle.lnth = rhslnth;
+    (s.shareEditSet_owns_ulink){ false };
+    for ( int i = 0; i < rhslnth; i += 1 ) {            // copy characters
+        Handle.s[i] = rhs[i];
+    } // for
+    s.shareEditSet_prev = &s;
+    s.shareEditSet_next = &s;
+}
+
 // General copy constructor
 void ?{}(string_res &s, const string_res & s2, StrResInitMode mode, size_t start, size_t end ) {
@@ -263 +276 @@
     verify( start <= end && end <= s2.Handle.lnth );
 
-    if (s2.Handle.ulink == ambient_string_sharectx->activeHeap) {
-        // same heap: allow overlap
+    if (s2.Handle.ulink != ambient_string_sharectx->activeHeap && mode == COPY_VALUE) {
+        // crossing heaps (including private): copy eagerly
+        eagerCopyCtorHelper(s, s2.Handle.s + start, end - start);
+        verify(s.shareEditSet_prev == &s);
+        verify(s.shareEditSet_next == &s);
+    } else {
         (s.Handle){};
         s.Handle.s = s2.Handle.s + start;
         s.Handle.lnth = end - start;
-        s.Handle.ulink = ambient_string_sharectx->activeHeap;
-        (s.shareEditSet_owns_ulink){ false };
+        s.Handle.ulink = s2.Handle.ulink;
+
         AddThisAfter(s.Handle, s2.Handle );                     // insert this handle after rhs handle
         // ^ bug?  skip others at early point in string
-    
+
         if (mode == COPY_VALUE) {
+            verify(s2.Handle.ulink == ambient_string_sharectx->activeHeap);
+            // requested logical copy in same heap: defer copy until write
+
+            (s.shareEditSet_owns_ulink){ false };
+
             // make s alone in its shareEditSet
             s.shareEditSet_prev = &s;
@@ -279 +301 @@
         } else {
             verify( mode == SHARE_EDITS );
+            // sharing edits with source forces same heap as source (ignore context)
+
+            (s.shareEditSet_owns_ulink){ s2.shareEditSet_owns_ulink };
 
             // s2 is logically const but not implementation const
@@ -289 +314 @@
             s.shareEditSet_prev->shareEditSet_next = &s;
         }
-    } else {
-        // crossing heaps: eager copy
-        assert( mode == COPY_VALUE && "need to solidify context-crossing rules for requesting shared edits");
-        eagerCopyCtorHelper(s, s2.Handle.s + start, end - start);
-        verify(s.shareEditSet_prev == &s);
-        verify(s.shareEditSet_next == &s);
     }
 }
@@ -400 +419 @@
             // growing: copy from old to new
             char * dest = VbyteAlloc( *this.Handle.ulink, editSetLength );
-            char *destCursor = dest;        memcpy(destCursor, prefixStartOrig, prefixLen);
-            destCursor += prefixLen;        memcpy(destCursor, buffer         , bsize    );
-            destCursor += this.Handle.lnth; memcpy(destCursor, suffixStartOrig, suffixLen);
+            char *destCursor = dest;  memcpy(destCursor, prefixStartOrig, prefixLen);
+            destCursor += prefixLen;  memcpy(destCursor, buffer         , bsize    );
+            destCursor += bsize;      memcpy(destCursor, suffixStartOrig, suffixLen);
             assignEditSet(this, shareEditSetStartPeer, shareEditSetEndPeer, 
                 dest,
@@ -437 +456 @@
         // `this` occurs in the middle of it, to be replaced
         // build up the new text in `pasting`
-
-        // super private string ctor: ignore ambient context
-        void ?{}( string_res &s, VbyteHeap & heap, const char* rhs, size_t rhslnth ) with(s) {
-            (Handle){ heap };
-            Handle.s = VbyteAlloc(*Handle.ulink, rhslnth);
-            Handle.lnth = rhslnth;
-            (s.shareEditSet_owns_ulink){ false };
-            for ( int i = 0; i < rhslnth; i += 1 ) {            // copy characters
-                Handle.s[i] = rhs[i];
-            } // for
-            s.shareEditSet_prev = &s;
-            s.shareEditSet_next = &s;
-        }
 
         string_res pasting = {
@@ -538 +544 @@
             VbyteAlloc( *str1.Handle.ulink, bsize ); // create room for 2nd part at the end of string area
         } else {                                        // copy the two parts
-            char * str1oldBuf = str1.Handle.s;
-            str1.Handle.s = VbyteAlloc( *str1.Handle.ulink, clnth );
+            char * str1newBuf = VbyteAlloc( *str1.Handle.ulink, clnth );
+            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);
         } // if