Changeset 0860d9c for libcfa

Timestamp:

Oct 5, 2023, 4:17:14 PM (7 months ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

master

Children:

4d860ea3

Parents:

b67b632

Message:

Fix read-to-variable-length-string cases when internal buffer fills.

Also fix read-to-cstring ability to give no-exception cases when an entire buffer fills.

The added test cases run, and fail, when run against prior libcfa.
Doing so illustrates a CFA-string-level bug.
Doing so illustrates a C-string-level changed semantics.

At the CFA-string level, the bug was, when reading strings of just the right length,
what should be two reads ("abc" then "def") gets mashed into one ("abcdef").
These cases are clearly bugs because a test program that just echoes chuncks of delimeted input would do so inaccurately.
They're just hard to drive because the relevant chunk lengths are implementation-dependent, and sometimes big.

At the C-string level, the semantic change concerns when to throw the cstring_length exception.
By this change, make the original semantics,
"An exception means the maximum number of characters was read," into
"An exception means that if the buffer were larger, then more characters would have been read."

The added test cases cover the respective stop conditions for manipulator state "%s", include, exclude, getline, and getline/delimiter.

Location:

libcfa/src

Files:

• collections/string_res.cfa (modified) (3 diffs)
• iostream.cfa (modified) (4 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"
 
@@ -991 +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 );
                 }
@@ -1018 +1027 @@
                 //fprintf( stderr, "KK %s %zd %d %c %s\n", fmtstr, len, check, f.s[check], f.s );
 
-                if (! f.flags.ignore && ! 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 ?