Changeset f45772e for libcfa

Timestamp:

Oct 8, 2023, 9:14:31 AM (2 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

92211d9

Parents:

2261bcc (diff), 9689e54 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

libcfa/src

Files:

• collections/string_res.cfa (modified) (3 diffs)
• iostream.cfa (modified) (5 diffs)

libcfa/src/collections/string_res.cfa

@@ -218 +218 @@
     // 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 (;;) {
+    for (bool cont = true; cont; ) {
+        cont = false;
+
         // 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
@@ -228 +230 @@
         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);
+        // rest of heap is available to read into
+        int lenReadable = (char*)temp.Handle.ulink->ExtVbyte - temp.Handle.ulink->EndVbyte;
+        assert (lenReadable >= 2);
 
         // get bytes
-        in | wdi( lenReadable + 1, lenReadable, temp.Handle.ulink->EndVbyte );
+        try {
+            in | wdi( lenReadable, temp.Handle.ulink->EndVbyte );
+        } catch (cstring_length*) {
+            cont = true;
+        }
         int lenWasRead = strlen(temp.Handle.ulink->EndVbyte);
 
@@ -239 +245 @@
         temp.Handle.lnth += lenWasRead;
         temp.Handle.ulink->EndVbyte += lenWasRead;
-
-      if (lenWasRead < lenReadable) break;
     }
 

libcfa/src/iostream.cfa

@@ -22 +22 @@
 #include <float.h>                                                                              // DBL_DIG, LDBL_DIG
 #include <complex.h>                                                                    // creal, cimag
+#include <ctype.h>                                                                              // isspace
 //#include <stdio.h>
 
@@ -29 +30 @@
 extern char *strcpy (char *__restrict __dest, const char *__restrict __src) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
 extern void *memcpy (void *__restrict __dest, const void *__restrict __src, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+extern char *strchr(const char *str, int ch);
 } // extern "C"
 
@@ -960 +962 @@
         istype & ?|?( istype & is, _Istream_Cskip f ) {
                 // printf( "skip %s %d\n", f.scanset, f.wd );
-                if ( f.scanset ) fmt( is, f.scanset, "" );              // no input arguments
+                if ( f.scanset ) {
+                        int nscanset = strlen(f.scanset);
+                        char fmtstr[ sizeof("%*[]") + nscanset ];
+                        int pos = 0;
+                        fmtstr[pos] = '%';                  pos += 1;
+                        fmtstr[pos] = '*';                  pos += 1;
+                        fmtstr[pos] = '[';                  pos += 1;
+                        strcpy( &fmtstr[pos], f.scanset );  pos += nscanset;
+                        fmtstr[pos] = ']';                  pos += 1;
+                        fmtstr[pos] = '\0';
+                        fmt( is, fmtstr, (void*)0 );  // last arg is dummy: suppress gcc warning
+                }
                 else for ( f.wd ) fmt( is, "%*c" );
                 return is;
@@ -980 +993 @@
                         // wd is buffer bytes available (for input chars + null terminator)
                         // rwd is count of input chars
-                        int rwd = f.flags.rwd ? f.wd : (f.wd - 1);
+                        int rwd;
+                        if (f.flags.rwd) {
+                                verify (f.wd >= 0);
+                                rwd = f.wd;
+                        } else {
+                                verify (f.wd >= 1);
+                                rwd = f.wd - 1;
+                        } // if
                         start += sprintf( &fmtstr[start], "%d", rwd );
                 }
@@ -1000 +1020 @@
 
                 int check = f.wd - 2;
-                if ( ! f.flags.rwd ) f.s[check] = '\0';                 // insert sentinel
+                if (! f.flags.ignore ) {
+                        f.s[0] = '\0';
+                        if ( ! f.flags.rwd ) f.s[check] = '\0';         // insert sentinel
+                }
                 len = fmt( is, fmtstr, f.s );
                 //fprintf( stderr, "KK %s %zd %d %c %s\n", fmtstr, len, check, f.s[check], f.s );
 
-                if ( ! f.flags.rwd && f.s[check] != '\0' )              // sentinel overwritten ?
-                        throw (cstring_length){ &cstring_length_vt };
+                if ( ! f.flags.ignore && ! f.flags.rwd && f.s[check] != '\0' ) { // sentinel overwritten ?
+                        // buffer filled, but would we have kept going?
+                        if ( ! eof( is ) ) {
+                                char peek;
+                                fmt( is, "%c", &peek );
+                                ungetc( is, peek );
+                                bool hasMore;
+                                if (f.flags.delimiter) { // getline
+                                        hasMore = (peek != f.delimiter[0]);
+                                } else if (f.scanset) { // incl/excl
+                                        bool peekMatch = strchr(f.scanset, peek) != 0p;
+                                        hasMore = f.flags.inex ? (!peekMatch) : (peekMatch);
+                                } else { // %s
+                                        hasMore = !isspace(peek);
+                                }
+                                if (hasMore) throw (cstring_length){ &cstring_length_vt };
+                        } // if
+                } // if
 
                 if ( f.flags.delimiter ) {                                              // getline ?