Changes in / [89bef959:8d96dee]

Files:

• libcfa/src/containers/string.cfa (modified) (2 diffs)
• libcfa/src/containers/string.hfa (modified) (1 diff)
• libcfa/src/containers/string_res.cfa (modified) (18 diffs)
• libcfa/src/containers/string_res.hfa (modified) (3 diffs)
• src/ControlStruct/ExceptDeclNew.cpp (modified) (4 diffs)
• src/Parser/StatementNode.cc (modified) (2 diffs)
• src/Parser/StatementNode.h (modified) (2 diffs)
• src/Parser/parser.yy (modified) (2 diffs)
• tests/collections/.expect/string-istream.txt (added)
• tests/collections/.in/string-istream.txt (added)
• tests/collections/string-istream.cfa (added)
• tests/io/.expect/manipulatorsOutput2.arm64.txt (modified) (1 diff)
• tests/io/.expect/manipulatorsOutput2.x86.txt (modified) (1 diff)
• tests/io/.expect/manipulatorsOutput3.arm64.txt (modified) (1 diff)
• tests/io/.expect/manipulatorsOutput3.txt (deleted)
• tests/io/.expect/manipulatorsOutput3.x64.txt (added)

libcfa/src/containers/string.cfa

@@ -10 +10 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug  7 10:07:26 2023
-// Update Count     : 2
+// Last Modified On : Sat Aug 12 15:24:18 2023
+// Update Count     : 6
 //
 
@@ -100 +100 @@
 
 ////////////////////////////////////////////////////////
-// Output
-
-ofstream & ?|?( ofstream & fs, const string & this ) {
-    return fs | (*this.inner);
-}
-
-void ?|?( ofstream & fs, const string & this ) {
-    fs | (*this.inner);
-}
+// Input-Output
+
+ofstream & ?|?( ofstream & out, const string & this ) {
+    return out | (*this.inner); // print internal string_res
+}
+
+void ?|?( ofstream & out, const string & this ) {
+    (ofstream &)(out | (*this.inner)); ends( out );
+}
+
+ifstream & ?|?(ifstream &in, string &this) {
+    return in | (*this.inner); // read to internal string_res
+}
+
 
 ////////////////////////////////////////////////////////

libcfa/src/containers/string.hfa

@@ -55 +55 @@
 ofstream & ?|?(ofstream &out, const string &s);
 void ?|?(ofstream &out, const string &s);
+ifstream & ?|?(ifstream &in, string &s);
 
 // Concatenation

libcfa/src/containers/string_res.cfa

@@ -10 +10 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jun 29 09:29:06 2023
-// Update Count     : 2
+// Last Modified On : Sat Aug 12 15:37:47 2023
+// Update Count     : 10
 //
 
@@ -17 +17 @@
 #include "string_sharectx.hfa"
 #include "stdlib.hfa"
+#include <ctype.h>
 
 // Workaround for observed performance penalty from calling CFA's alloc.
@@ -134 +135 @@
         serr | nlOff;
         serr | " lnth:" | lnth | " s:" | (void *)s | ",\"";
-        for ( int i = 0; i < lnth; i += 1 ) {
+        for ( i; lnth ) {
             serr | s[i];
         } // for
@@ -198 +199 @@
 // Output operator
 ofstream & ?|?(ofstream &out, const string_res &s) {
-    // Store auto-newline state so it can be restored
-    bool anl = getANL$(out);
-    nlOff(out);
-    for (size_t i = 0; i < s.Handle.lnth; i++) {
-        out | s[i];
-    }
-    out | sepVal;
-    // Re-apply newlines after done, for chaining version
-    if (anl) nlOn(out);
+        // CFA string is NOT null terminated, so print exactly lnth characters in a minimum width of 0.
+        out | wd( 0, s.Handle.lnth, s.Handle.s ) | nonl;
     return out;
 }
 
 void ?|?(ofstream &out, const string_res &s) {
-    // Store auto-newline state so it can be restored
-    bool anl = getANL$(out);
-    if( s.Handle.lnth == 0 ) {
-        sout | "";
-    } else {
-        nlOff(out);
-        for (size_t i = 0; i < s.Handle.lnth; i++) {
-            // Need to re-apply on the last output operator, for whole-statement version
-            if (anl && i == s.Handle.lnth-1) nlOn(out);
-            out | s[i];
-        }
-    }
-}
+        (ofstream &)(out | s); ends( out );
+}
+
+// Input operator
+ifstream & ?|?(ifstream &in, string_res &s) {
+
+    // Reading into a temp before assigning to s is near zero overhead in typical cases because of sharing.
+    // If s is a substring of something larger, simple assignment takes care of that case correctly.
+    // But directly reading a variable amount of text into the middle of a larger context is not practical.
+    string_res temp;
+
+    // Read in chunks.  Often, one chunk is enough.  Keep the string that accumulates chunks last in the heap,
+    // so available room is rest of heap.  When a chunk fills the heap, force growth then take the next chunk.
+    for (;;) {
+        // Append dummy content to temp, forcing expansion when applicable (occurs always on subsequent loops)
+        // length 2 ensures room for at least one real char, plus scanf/pipe-cstr's null terminator
+        temp += "--";
+        assert( temp.Handle.ulink->EndVbyte == temp.Handle.s + temp.Handle.lnth );    // last in heap
+
+        // reset, to overwrite the appended "--"
+        temp.Handle.lnth -= 2;
+        temp.Handle.ulink->EndVbyte -= 2;
+
+        // rest of heap, less 1 byte for null terminator, is available to read into
+        int lenReadable = (char*)temp.Handle.ulink->ExtVbyte - temp.Handle.ulink->EndVbyte - 1;
+        assert (lenReadable >= 1);
+
+        // get bytes
+        in | wdi( lenReadable, temp.Handle.ulink->EndVbyte );
+        int lenWasRead = strlen(temp.Handle.ulink->EndVbyte);
+
+        // update metadata
+        temp.Handle.lnth += lenWasRead;
+        temp.Handle.ulink->EndVbyte += lenWasRead;
+
+      if (lenWasRead < lenReadable) break;
+    }
+
+    s = temp;
+    return in;
+}
+
 
 // Empty constructor
@@ -338 +361 @@
     // 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 = this.shareEditSet_next; p != &this; p = p->shareEditSet_next) {
+    for ( string_res * p = this.shareEditSet_next; p != &this; p = p->shareEditSet_next ) {
         verify (p->Handle.s >= beforeBegin);
         if ( p->Handle.s >= afterBegin ) {
@@ -391 +414 @@
 }
 
-static string_res & assign_(string_res &this, const char* buffer, size_t bsize, const string_res & valSrc) {
-
-    // traverse the incumbent share-edit set (SES) to recover the range of a base string to which `this` belongs
-    string_res * shareEditSetStartPeer = & this;
-    string_res * shareEditSetEndPeer = & this;
+// traverse the share-edit set (SES) to recover the range of a base string to which `this` belongs
+static void locateInShareEditSet( string_res &this, string_res *&shareEditSetStartPeer, string_res *&shareEditSetEndPeer ) {
+    shareEditSetStartPeer = & this;
+    shareEditSetEndPeer = & this;
     for (string_res * editPeer = this.shareEditSet_next; editPeer != &this; editPeer = editPeer->shareEditSet_next) {
         if ( editPeer->Handle.s < shareEditSetStartPeer->Handle.s ) {
@@ -404 +426 @@
         }
     }
+}
+
+static string_res & assign_(string_res &this, const char* buffer, size_t bsize, const string_res & valSrc) {
+
+    string_res * shareEditSetStartPeer;
+    string_res * shareEditSetEndPeer;
+    locateInShareEditSet( this, shareEditSetStartPeer, shareEditSetEndPeer );
 
     verify( shareEditSetEndPeer->Handle.s >= shareEditSetStartPeer->Handle.s );
@@ -589 +618 @@
 
 bool contains(const string_res &s, char ch) {
-    for (i; size(s)) {
+    for ( i; size(s) ) {
         if (s[i] == ch) return true;
     }
@@ -643 +672 @@
     }
 
-    for (size_t i = fromPos; i < s.Handle.lnth; i++) {
+    for ( i; fromPos ~ s.Handle.lnth ) {
         size_t remaining = s.Handle.lnth - i;
         // Never going to find the search string if the remaining string is
@@ -652 +681 @@
 
         bool matched = true;
-        for (size_t j = 0; j < searchsize; j++) {
+        for ( j; searchsize ) {
             if (search[j] != s.Handle.s[i + j]) {
                 matched = false;
@@ -740 +769 @@
 
 int exclude(const string_res &s, const charclass_res &mask) {
-    for (int i = 0; i < size(s); i++) {
+    for ( i; size(s) ) {
         if ( test(mask, s[i]) ) return i;
     }
@@ -747 +776 @@
 
 int include(const string_res &s, const charclass_res &mask) {
-    for (int i = 0; i < size(s); i++) {
+    for ( i; size(s) ) {
         if ( ! test(mask, s[i]) ) return i;
     }
@@ -775 +804 @@
                 for ( HandleNode *ni = HeaderPtr->flink; ni != HeaderPtr; ni = ni->flink ) {
                         serr | "\tnode:" | ni | " lnth:" | ni->lnth | " s:" | (void *)ni->s | ",\"";
-                        for ( int i = 0; i < ni->lnth; i += 1 ) {
+                        for ( i; ni->lnth ) {
                                 serr | ni->s[i];
                         } // for
@@ -881 +910 @@
         for ( HandleNode *n = HeaderPtr->flink; n != HeaderPtr; n = n->flink ) {
             serr | "\tnode:" | n | " lnth:" | n->lnth | " s:" | (void *)n->s | ",\"";
-            for ( int i = 0; i < n->lnth; i += 1 ) {
-                serr | n->s[i];
+            for ( i; n->lnth ) {
+                        serr | n->s[i];
             } // for
             serr | "\" flink:" | n->flink | " blink:" | n->blink | nl;
@@ -960 +989 @@
     EndVbyte = StartVbyte;
     h = Header.flink;                                   // ignore header node
-    for (;;) {
+    for () {
                 memmove( EndVbyte, h->s, h->lnth );
                 obase = h->s;
@@ -971 +1000 @@
                 // check if any substrings are allocated within a string
                 
-                for (;;) {
+                for () {
                         if ( h == &Header ) break;                      // end of header list ?
                         if ( h->s >= limit ) break;                     // outside of current string ?
@@ -1001 +1030 @@
                         serr | nlOff;
                         serr | "\tnode:" | n | " lnth:" | n->lnth | " s:" | (void *)n->s | ",\"";
-                        for ( int i = 0; i < n->lnth; i += 1 ) {
+                        for ( i; n->lnth ) {
                                 serr | n->s[i];
                         } // for
@@ -1036 +1065 @@
                         serr | nlOff;
                         serr | "\tnode:" | n | " lnth:" | n->lnth | " s:" | (void *)n->s | ",\"";
-                        for ( int i = 0; i < n->lnth; i += 1 ) {
+                        for ( i; n->lnth ) {
                                 serr | n->s[i];
                         } // for

libcfa/src/containers/string_res.hfa

@@ -9 +9 @@
 // Author           : Michael L. Brooks
 // Created On       : Fri Sep 03 11:00:00 2021
-// Last Modified By : Michael L. Brooks
-// Last Modified On : Fri Sep 03 11:00:00 2021
-// Update Count     : 1
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Aug 12 15:45:47 2023
+// Update Count     : 2
 //
 
@@ -30 +30 @@
     VbyteHeap *ulink;                   // upward link
 
-    char *s;                                            // pointer to byte string
+    char *s;                                                    // pointer to byte string
     unsigned int lnth;                                  // length of byte string
 }; // HandleNode
@@ -101 +101 @@
 ofstream & ?|?(ofstream &out, const string_res &s);
 void ?|?(ofstream &out, const string_res &s);
+ifstream & ?|?(ifstream &in, string_res &s);
 
 // Concatenation

src/ControlStruct/ExceptDeclNew.cpp

@@ -242 +242 @@
 }
 
-static ast::ObjectDecl * createExternVTable(
+ast::ObjectDecl * createExternVTable(
                 CodeLocation const & location,
                 std::string const & exceptionName,
@@ -453 +453 @@
         std::string const & tableName = decl->name;
 
-    ast::ObjectDecl * retDecl;
+        ast::ObjectDecl * retDecl;
         if ( decl->storage.is_extern ) {
                 // Unique type-ids are only needed for polymorphic instances.
@@ -475 +475 @@
         }
 
-    for ( ast::ptr<ast::Attribute> const & attr : decl->attributes ) {
-        retDecl->attributes.push_back( attr );
-    }
-
-    return retDecl;
+        for ( ast::ptr<ast::Attribute> const & attr : decl->attributes ) {
+                retDecl->attributes.push_back( attr );
+        }
+
+        return retDecl;
 }
 
@@ -485 +485 @@
         ast::StructInstType const * postvisit( ast::VTableType const * type ) {
                 auto inst = type->base.as<ast::BaseInstType>();
-        
+
                 std::string vtableName = Virtual::vtableTypeName( inst->name );
 

src/Parser/StatementNode.cc

@@ -10 +10 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 14:59:41 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Apr 11 10:16:00 2023
-// Update Count     : 428
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Aug 11 11:44:15 2023
+// Update Count     : 429
 //
 
@@ -374 +374 @@
 }
 
-ast::WaitUntilStmt::ClauseNode * build_waituntil_timeout( const CodeLocation & loc, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ) {
-        ast::WhenClause * clause = new ast::WhenClause( loc );
-        clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
-        clause->stmt = maybeMoveBuild( stmt );
-        clause->target = maybeMoveBuild( timeout );
-        return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::TIMEOUT, clause );
-}
-
 ast::WaitUntilStmt * build_waituntil_stmt( const CodeLocation & loc, ast::WaitUntilStmt::ClauseNode * root ) {
         ast::WaitUntilStmt * retStmt = new ast::WaitUntilStmt( loc );

src/Parser/StatementNode.h

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Wed Apr  5 11:42:00 2023
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Apr 11  9:43:00 2023
-// Update Count     : 1
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Aug 11 11:44:07 2023
+// Update Count     : 2
 //
 
@@ -102 +102 @@
 ast::WaitUntilStmt::ClauseNode * build_waituntil_clause( const CodeLocation &, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt );
 ast::WaitUntilStmt::ClauseNode * build_waituntil_else( const CodeLocation &, ExpressionNode * when, StatementNode * stmt );
-ast::WaitUntilStmt::ClauseNode * build_waituntil_timeout( const CodeLocation &, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt );
 ast::WaitUntilStmt * build_waituntil_stmt( const CodeLocation &, ast::WaitUntilStmt::ClauseNode * root );
 ast::Stmt * build_with( const CodeLocation &, ExpressionNode * exprs, StatementNode * stmt );

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jul 12 23:06:44 2023
-// Update Count     : 6389
+// Last Modified On : Tue Jul 18 22:51:30 2023
+// Update Count     : 6391
 //
 
@@ -1708 +1708 @@
         | wor_waituntil_clause wor when_clause_opt ELSE statement
                 { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_else( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
-        | wor_waituntil_clause wor when_clause_opt timeout statement    %prec THEN
-                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ) ); }
-        // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
-        | wor_waituntil_clause wor when_clause_opt timeout statement wor ELSE statement // invalid syntax rule
-                { SemanticError( yylloc, "syntax error, else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
-        | wor_waituntil_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
-                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1,
-                                new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::OR, 
-                                        build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ), 
-                                        build_waituntil_else( yylloc, $7, maybe_build_compound( yylloc, $9 ) ) ) ); }
         ;
 
 waituntil_statement:
         wor_waituntil_clause                                                            %prec THEN
-                // SKULLDUGGERY: create an empty compound statement to test parsing of waituntil statement.
-                {
-                        $$ = new StatementNode( build_waituntil_stmt( yylloc, $1 ) );
-                        // $$ = new StatementNode( build_compound( yylloc, nullptr ) );
-                }
+                { $$ = new StatementNode( build_waituntil_stmt( yylloc, $1 ) ); }
         ;
 

tests/io/.expect/manipulatorsOutput2.arm64.txt

@@ -4 +4 @@
 0 033 033 033 033
 0345 0177745 037777777745 01777777777777777777745
-0 0x1b 0x1b 0x1b 0x1b
+0x0 0x1b 0x1b 0x1b 0x1b
 0xe5 0xffe5 0xffffffe5 0xffffffffffffffe5
-0x0p+0. 0x1.b8p+4 0x1.b8p+4 0x1.b8p+4
+0x0p+0 0x1.b8p+4 0x1.b8p+4 0x1.b8p+4
 -0x1.b8p+4 -0x1.b8p+4 -0x1.b8p+4
 0.000000e+00 2.750000e+01 -2.750000e+01

tests/io/.expect/manipulatorsOutput2.x86.txt

@@ -4 +4 @@
 0 033 033 033 033
 0345 0177745 037777777745 037777777745
-0 0x1b 0x1b 0x1b 0x1b
+0x0 0x1b 0x1b 0x1b 0x1b
 0xe5 0xffe5 0xffffffe5 0xffffffe5
-0x0p+0. 0x1.b8p+4 0x1.b8p+4 0xd.cp+1
+0x0p+0 0x1.b8p+4 0x1.b8p+4 0xd.cp+1
 -0x1.b8p+4 -0x1.b8p+4 -0xd.cp+1
 0.000000e+00 2.750000e+01 -2.750000e+01

tests/io/.expect/manipulatorsOutput3.arm64.txt

@@ -246 +246 @@
 -1                   0xffffffffffffffffffffffffffffffff 03777777777777777777777777777777777777777777
 0b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
-+0                   0                    0                   
++0                   0x0                  0                   
 0b0                 
 +1                   0x1                  01