Index: libcfa/src/collections/string_res.cfa =================================================================== --- libcfa/src/collections/string_res.cfa (revision 3ac5fd8bcb3728ce8676e2b55b9fd4f691a06719) +++ libcfa/src/collections/string_res.cfa (revision 379b6ea2877f786ddcc4f854aef2c757966b114d) @@ -10,6 +10,6 @@ // Created On : Fri Sep 03 11:00:00 2021 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Aug 17 14:08:01 2024 -// Update Count : 86 +// Last Modified On : Fri Mar 14 15:45:24 2025 +// Update Count : 88 // @@ -319,14 +319,14 @@ if( ambient_string_sharectx->activeHeap ) { (Handle){ * ambient_string_sharectx->activeHeap }; - (shareEditSet_owns_ulink){ false }; + (shareSet_owns_ulink){ false }; verify( Handle.s == 0p && Handle.lnth == 0 ); } else { (Handle){ * new( (size_t) 10 ) }; // TODO: can I lazily avoid allocating for empty string - (shareEditSet_owns_ulink){ true }; + (shareSet_owns_ulink){ true }; Handle.s = Handle.ulink->StartVbyte; verify( Handle.lnth == 0 ); } - s.shareEditSet_prev = &s; - s.shareEditSet_next = &s; + s.shareSet_prev = &s; + s.shareSet_next = &s; } @@ -334,14 +334,14 @@ if( ambient_string_sharectx->activeHeap ) { (Handle){ * ambient_string_sharectx->activeHeap }; - (shareEditSet_owns_ulink){ false }; + (shareSet_owns_ulink){ false }; } else { (Handle){ * new( rhslnth ) }; - (shareEditSet_owns_ulink){ true }; + (shareSet_owns_ulink){ true }; } Handle.s = VbyteAlloc(*Handle.ulink, rhslnth); Handle.lnth = rhslnth; memmove( Handle.s, rhs, rhslnth ); - s.shareEditSet_prev = &s; - s.shareEditSet_next = &s; + s.shareSet_prev = &s; + s.shareSet_next = &s; } @@ -393,8 +393,8 @@ Handle.s = VbyteAlloc(*Handle.ulink, rhslnth); Handle.lnth = rhslnth; - (s.shareEditSet_owns_ulink){ false }; + (s.shareSet_owns_ulink){ false }; memmove( Handle.s, rhs, rhslnth ); - s.shareEditSet_prev = &s; - s.shareEditSet_next = &s; + s.shareSet_prev = &s; + s.shareSet_next = &s; } @@ -408,6 +408,6 @@ // crossing heaps (including private): copy eagerly eagerCopyCtorHelper(s, s2.Handle.s + start, end - start); - verify(s.shareEditSet_prev == &s); - verify(s.shareEditSet_next == &s); + verify(s.shareSet_prev == &s); + verify(s.shareSet_next == &s); } else { (s.Handle){}; @@ -423,37 +423,37 @@ // 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; - s.shareEditSet_next = &s; + (s.shareSet_owns_ulink){ false }; + + // make s alone in its shareSet + s.shareSet_prev = &s; + s.shareSet_next = &s; } else { verify( mode == SHARE_EDITS ); // sharing edits with source forces same heap as source (ignore context) - (s.shareEditSet_owns_ulink){ s2.shareEditSet_owns_ulink }; + (s.shareSet_owns_ulink){ s2.shareSet_owns_ulink }; // s2 is logically const but not implementation const string_res & s2mod = (string_res &) s2; - // insert s after s2 on shareEditSet - s.shareEditSet_next = s2mod.shareEditSet_next; - s.shareEditSet_prev = &s2mod; - s.shareEditSet_next->shareEditSet_prev = &s; - s.shareEditSet_prev->shareEditSet_next = &s; + // insert s after s2 on shareSet + s.shareSet_next = s2mod.shareSet_next; + s.shareSet_prev = &s2mod; + s.shareSet_next->shareSet_prev = &s; + s.shareSet_prev->shareSet_next = &s; } } } -static void assignEditSet(string_res & s, string_res * shareEditSetStartPeer, string_res * shareEditSetEndPeer, +static void assignEditSet(string_res & s, string_res * shareSetStartPeer, string_res * shareSetEndPeer, char * resultSesStart, size_t resultSesLnth, HandleNode * resultPadPosition, size_t bsize ) { - char * beforeBegin = shareEditSetStartPeer->Handle.s; + char * beforeBegin = shareSetStartPeer->Handle.s; 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 afterLen = shareSetEndPeer->Handle.s + shareSetEndPeer->Handle.lnth - afterBegin; size_t oldLnth = s.Handle.lnth; @@ -466,5 +466,5 @@ // 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 = s.shareEditSet_next; p != &s; p = p->shareEditSet_next ) { + for ( string_res * p = s.shareSet_next; p != &s; p = p->shareSet_next ) { verify (p->Handle.s >= beforeBegin); if ( p->Handle.s >= afterBegin ) { @@ -520,13 +520,13 @@ // 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; +static void locateInShareSet( string_res & s, string_res *& shareSetStartPeer, string_res *& shareSetEndPeer ) { + shareSetStartPeer = & s; + shareSetEndPeer = & s; + for (string_res * editPeer = s.shareSet_next; editPeer != &s; editPeer = editPeer->shareSet_next) { + if ( editPeer->Handle.s < shareSetStartPeer->Handle.s ) { + shareSetStartPeer = editPeer; } - if ( shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth < editPeer->Handle.s + editPeer->Handle.lnth) { - shareEditSetEndPeer = editPeer; + if ( shareSetEndPeer->Handle.s + shareSetEndPeer->Handle.lnth < editPeer->Handle.s + editPeer->Handle.lnth) { + shareSetEndPeer = editPeer; } } @@ -534,18 +534,18 @@ static string_res & assign_(string_res & s, const char * buffer, size_t bsize, const string_res & valSrc) { - string_res * shareEditSetStartPeer; - string_res * shareEditSetEndPeer; - locateInShareEditSet( s, shareEditSetStartPeer, shareEditSetEndPeer ); - - verify( shareEditSetEndPeer->Handle.s >= shareEditSetStartPeer->Handle.s ); - size_t origEditSetLength = shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth - shareEditSetStartPeer->Handle.s; + string_res * shareSetStartPeer; + string_res * shareSetEndPeer; + locateInShareSet( s, shareSetStartPeer, shareSetEndPeer ); + + verify( shareSetEndPeer->Handle.s >= shareSetStartPeer->Handle.s ); + size_t origEditSetLength = shareSetEndPeer->Handle.s + shareSetEndPeer->Handle.lnth - shareSetStartPeer->Handle.s; verify( origEditSetLength >= s.Handle.lnth ); - if ( s.shareEditSet_owns_ulink ) { // assigning to private context + if ( s.shareSet_owns_ulink ) { // assigning to private context // ok to overwrite old value within LHS - char * prefixStartOrig = shareEditSetStartPeer->Handle.s; + char * prefixStartOrig = shareSetStartPeer->Handle.s; int prefixLen = s.Handle.s - prefixStartOrig; char * suffixStartOrig = s.Handle.s + s.Handle.lnth; - int suffixLen = shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth - suffixStartOrig; + int suffixLen = shareSetEndPeer->Handle.s + shareSetEndPeer->Handle.lnth - suffixStartOrig; int delta = bsize - s.Handle.lnth; @@ -556,5 +556,5 @@ destCursor += prefixLen; memcpy(destCursor, buffer , bsize ); destCursor += bsize; memcpy(destCursor, suffixStartOrig, suffixLen); - assignEditSet(s, shareEditSetStartPeer, shareEditSetEndPeer, + assignEditSet(s, shareSetStartPeer, shareSetEndPeer, dest, origEditSetLength + delta, @@ -566,6 +566,6 @@ memcpy( s.Handle.s, buffer, bsize ); - assignEditSet(s, shareEditSetStartPeer, shareEditSetEndPeer, - shareEditSetStartPeer->Handle.s, + assignEditSet(s, shareSetStartPeer, shareSetEndPeer, + shareSetStartPeer->Handle.s, origEditSetLength + delta, 0p, bsize); @@ -578,5 +578,5 @@ // SES's result will only use characters from the source string => reuse source - assignEditSet(s, shareEditSetStartPeer, shareEditSetEndPeer, + assignEditSet(s, shareSetStartPeer, shareSetEndPeer, valSrc.Handle.s, valSrc.Handle.lnth, @@ -587,5 +587,5 @@ // OR we are importing characters: need to copy eagerly (can't refer to source) - // full string is from start of shareEditSetStartPeer thru end of shareEditSetEndPeer + // full string is from start of shareSetStartPeer thru end of shareSetEndPeer // `s` occurs in the middle of it, to be replaced // build up the new text in `pasting` @@ -593,6 +593,6 @@ string_res pasting = { * s.Handle.ulink, // maintain same heap, regardless of context - shareEditSetStartPeer->Handle.s, // start of SES - s.Handle.s - shareEditSetStartPeer->Handle.s }; // length of SES, before s + shareSetStartPeer->Handle.s, // start of SES + s.Handle.s - shareSetStartPeer->Handle.s }; // length of SES, before s append( pasting, buffer, // start of replacement for s @@ -600,5 +600,5 @@ append( pasting, s.Handle.s + s.Handle.lnth, // start of SES after s - shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth - + shareSetEndPeer->Handle.s + shareSetEndPeer->Handle.lnth - (s.Handle.s + s.Handle.lnth) ); // length of SES, after s @@ -607,5 +607,5 @@ // From s point on, they are stable. - assignEditSet(s, shareEditSetStartPeer, shareEditSetEndPeer, + assignEditSet(s, shareSetStartPeer, shareSetEndPeer, pasting.Handle.s, pasting.Handle.lnth, @@ -675,10 +675,10 @@ // sever s from its share-edit peers, if any (four no-ops when already solo) - s.shareEditSet_prev->shareEditSet_next = s.shareEditSet_next; - s.shareEditSet_next->shareEditSet_prev = s.shareEditSet_prev; - // s.shareEditSet_next = &s; - // s.shareEditSet_prev = &s; - - if (shareEditSet_owns_ulink && s.shareEditSet_next == &s) { // last one out + s.shareSet_prev->shareSet_next = s.shareSet_next; + s.shareSet_next->shareSet_prev = s.shareSet_prev; + // s.shareSet_next = &s; + // s.shareSet_prev = &s; + + if (shareSet_owns_ulink && s.shareSet_next == &s) { // last one out delete( s.Handle.ulink ); }