Changeset 0f781fb8 for libcfa/src/containers/string_res.cfa

Timestamp:

Sep 29, 2021, 10:46:52 PM (3 years ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

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

Children:

4b3b352

Parents:

218096f

Message:

Refactoring of string internals. Existing tests pass.

Adding tracking for multiple string heaps, or "scratchpads."
Cases of allocating across different pad contexts aren't implemented yet.
Adding basic controls to manage these contexts, which lead to expected assertion failures
at unimplemented cases.

File:

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

libcfa/src/containers/string_res.cfa

@@ -15 +15 @@
 
 #include "string_res.hfa"
+#include "string_sharectx.hfa"
+
 #include <stdlib.hfa>  // e.g. malloc
 #include <string.h>    // e.g. strlen
@@ -20 +22 @@
 
 //######################### VbyteHeap "header" #########################
-
-
-
-
-
-
-
-
-// DON'T COMMIT:
-// #define VbyteDebug
-
-
-
-
 
 #ifdef VbyteDebug
@@ -62 +50 @@
 static inline void ?{}( VbyteHeap &, int = 1000 );
 static inline void ^?{}( VbyteHeap & );
-static inline void ByteCopy( VbyteHeap &, char *, int, int, char *, int, int ); // copy a block of bytes from one location in the heap to another
-static inline int ByteCmp( VbyteHeap &, char *, int, int, char *, int, int );   // compare 2 blocks of bytes
+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
 
@@ -83 +71 @@
     ExtVbyte = (void *)( StartVbyte + CurrSize );
     Header.flink = Header.blink = &Header;
+    Header.ulink = & this;
 #ifdef VbyteDebug
     HeaderPtr = &Header;
@@ -124 +113 @@
     s = 0;
     lnth = 0;
+    ulink = &vh;
     AddThisAfter( this, *vh.Header.blink );
 #ifdef VbyteDebug
@@ -150 +140 @@
 } // ~HandleNode
 
+
+//######################### String Sharing Context #########################
+
+static string_sharectx * ambient_string_sharectx;               // fickle top of stack
+static string_sharectx default_string_sharectx = {NEW_SHARING}; // stable bottom of stack
+
+void ?{}( string_sharectx & this, StringSharectx_Mode mode ) with( this ) {
+    (older){ ambient_string_sharectx };
+    if ( mode == NEW_SHARING ) {
+        (activeHeap){ new( 1000 ) };
+    } else {
+        verify( mode == NO_SHARING );
+        (activeHeap){ 0p };
+    }
+    ambient_string_sharectx = & this;
+}
+
+void ^?{}( string_sharectx & this ) with( this ) {
+    if ( activeHeap ) delete( activeHeap );
+
+    // unlink this from older-list starting from ambient_string_sharectx
+    // usually, this==ambient_string_sharectx and the loop runs zero times
+    string_sharectx *& c = ambient_string_sharectx;
+    while ( c != &this ) &c = &c->older;              // find this
+    c = this.older;                                   // unlink
+}
+
 //######################### String Resource #########################
 
 
-VbyteHeap HeapArea;
-
-VbyteHeap * DEBUG_string_heap = & HeapArea;
+VbyteHeap * DEBUG_string_heap() {
+    assert( ambient_string_sharectx->activeHeap && "No sharing context is active" );
+    return ambient_string_sharectx->activeHeap;
+}
 
 size_t DEBUG_string_bytes_avail_until_gc( VbyteHeap * heap ) {
@@ -199 +217 @@
 // Empty constructor
 void ?{}(string_res &s) with(s) {
-    (Handle){ HeapArea };
+    assert( ambient_string_sharectx->activeHeap && "Need to implement private contexts" );
+    (Handle){ * ambient_string_sharectx->activeHeap };
     s.shareEditSet_prev = &s;
     s.shareEditSet_next = &s;
@@ -206 +225 @@
 // Constructor from a raw buffer and size
 void ?{}(string_res &s, const char* rhs, size_t rhslnth) with(s) {
-    (Handle){ HeapArea };
-    Handle.s = VbyteAlloc(HeapArea, rhslnth);
+    assert( ambient_string_sharectx->activeHeap && "Need to implement private contexts" );
+    (Handle){ * ambient_string_sharectx->activeHeap };
+    Handle.s = VbyteAlloc(*Handle.ulink, rhslnth);
     Handle.lnth = rhslnth;
     for ( int i = 0; i < rhslnth; i += 1 ) {            // copy characters
@@ -224 +244 @@
 void ?{}(string_res &s, const string_res & s2, StrResInitMode mode, size_t start, size_t end ) {
 
+    assert( ambient_string_sharectx->activeHeap && "Need to implement private contexts" );
+    assert( s2.Handle.ulink == ambient_string_sharectx->activeHeap && "need to implement context crossing");
+
     verify( start <= end && end <= s2.Handle.lnth );
 
@@ -229 +252 @@
     s.Handle.s = s2.Handle.s + start;
     s.Handle.lnth = end - start;
+    s.Handle.ulink = ambient_string_sharectx->activeHeap;
     AddThisAfter(s.Handle, s2.Handle );                 // insert this handle after rhs handle
     // ^ bug?  skip others at early point in string
@@ -404 +428 @@
         // no-op
     } else {                                            // must copy some text
-        if ( str1.Handle.s + size(str1) == VbyteAlloc(HeapArea, 0) ) { // str1 at end of string area ?
-            VbyteAlloc(HeapArea, bsize); // create room for 2nd part at the end of string area
+        if ( str1.Handle.s + size(str1) == 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
             char * str1oldBuf = str1.Handle.s;
-            str1.Handle.s = VbyteAlloc( HeapArea, clnth );
-            ByteCopy( HeapArea, str1.Handle.s, 0, str1.Handle.lnth, str1oldBuf, 0, str1.Handle.lnth);
+            str1.Handle.s = VbyteAlloc( *str1.Handle.ulink, clnth );
+            ByteCopy( str1.Handle.s, 0, str1.Handle.lnth, str1oldBuf, 0, str1.Handle.lnth);
         } // if
-        ByteCopy( HeapArea, str1.Handle.s, str1.Handle.lnth, bsize, (char*)buffer, 0, (int)bsize);
+        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 
     } // if
@@ -437 +461 @@
 
 bool ?==?(const string_res &s1, const string_res &s2) {
-    return ByteCmp( HeapArea, s1.Handle.s, 0, s1.Handle.lnth, s2.Handle.s, 0, s2.Handle.lnth) == 0;
+    return ByteCmp( s1.Handle.s, 0, s1.Handle.lnth, s2.Handle.s, 0, s2.Handle.lnth) == 0;
 }
 
@@ -608 +632 @@
     serr | "enter:AddThisAfter, this:" | &this | " n:" | &n;
 #endif // VbyteDebug
+    verify( n.ulink != 0p );
+    verify( this.ulink == n.ulink );
     flink = n.flink;
     blink = &n;
@@ -682 +708 @@
     serr | "enter:MoveThisAfter, this:" | & this | " h:" | & h;
 #endif // VbyteDebug
+    verify( h.ulink != 0p );
+    verify( this.ulink == h.ulink );
     if ( s < h.s ) {                                    // check argument values
                 // serr | "VbyteSM: Error - Cannot move byte string starting at:" | s | " after byte string starting at:"
@@ -723 +751 @@
 // if the |Dst| > |Src| => pad Dst with blanks
 
-void ByteCopy( VbyteHeap & this, char *Dst, int DstStart, int DstLnth, char *Src, int SrcStart, int SrcLnth ) {
+void ByteCopy( char *Dst, int DstStart, int DstLnth, char *Src, int SrcStart, int SrcLnth ) {
     for ( int i = 0; i < DstLnth; i += 1 ) {
       if ( i == SrcLnth ) {                             // |Dst| > |Src|
@@ -741 +769 @@
 // -1 => Src1-byte-string < Src2-byte-string
 
-int ByteCmp( VbyteHeap & this, char *Src1, int Src1Start, int Src1Lnth, char *Src2, int Src2Start, int Src2Lnth )  with(this) {
+int ByteCmp( char *Src1, int Src1Start, int Src1Lnth, char *Src2, int Src2Start, int Src2Lnth )  {
 #ifdef VbyteDebug
     serr | "enter:ByteCmp, Src1Start:" | Src1Start | " Src1Lnth:" | Src1Lnth | " Src2Start:" | Src2Start | " Src2Lnth:" | Src2Lnth;
@@ -798 +826 @@
     h = Header.flink;                                   // ignore header node
     for (;;) {
-                ByteCopy( this, EndVbyte, 0, h->lnth, h->s, 0, h->lnth );
+                ByteCopy( EndVbyte, 0, h->lnth, h->s, 0, h->lnth );
                 obase = h->s;
                 h->s = EndVbyte;