libc: Implement ungetc

apps/buffer-test.cpp

@@ -4,7 +4,7 @@
 
 int main()
 {
-    fprintf(stderr, "Writing incomplete line to stdout (_IOLBF=%d)...\n", stdout->_mode);
+    fprintf(stderr, "Writing incomplete line to stdout (_IOLBF=%d)...\n", stdout->_buf.mode);
     fputs("hi!", stdout);
     sleep(3);
     putchar('\n');
@@ -14,7 +14,7 @@ int main()
     assert(f);
     assert(setvbuf(f, NULL, _IOFBF, 0) == 0);
 
-    fprintf(stderr, "Writing long text to file (_IOFBF=%d)...\n", f->_mode);
+    fprintf(stderr, "Writing long text to file (_IOFBF=%d)...\n", f->_buf.mode);
 
     fputs("Hello world!\nHow are you doing!\nThis is a test for many lines of buffering.\n", f);
 

libc/include/stdio.h

@@ -14,16 +14,19 @@
 
 typedef struct
 {
-    int _fd;
-    int _err;
-    int _eof;
-    size_t _bufcap;
-    size_t _bufsize;
-    size_t _bufindex;
-    char* _buffer;
-    int _flags;
-    int _pending;
-    int _mode;
+    int _fd;  // The underlying file descriptor.
+    int _err; // The error status flag.
+    int _eof; // The end-of-file status flag.
+    struct
+    {
+        size_t capacity; // The buffer's total capacity.
+        size_t size;     // The buffer's used size.
+        size_t index;    // The read index into the buffer.
+        char* buffer;    // The memory used for the buffer.
+        int status;      // The buffer status flags.
+        int mode;        // The buffering mode.
+    } _buf;
+    int _flags; // The file access mode with which the file was opened.
 } FILE;
 
 #define EOF -1

libc/src/stdio.cpp

@@ -13,7 +13,12 @@ FILE* stdout = nullptr;
 
 FILE* s_open_files[FOPEN_MAX];
 
-#define FFLAG_FREE_AFTER_BUFFER_USE (1 << 0)
+enum FileStatusFlags
+{
+    BufferIsMalloced = (1 << 0),
+    LastRead = (1 << 1),
+    LastWrite = (1 << 2),
+};
 
 static const char* read_tmpdir()
 {
@@ -57,16 +62,34 @@ static int fdopen_check_compatible_mode(int fd, int new_flags)
 
 static int flush_write_buffer(FILE* stream)
 {
-    if (stream->_mode == _IONBF) return 0;
+    if (stream->_buf.mode == _IONBF) return 0;
 
-    ssize_t result = write(stream->_fd, stream->_buffer, stream->_bufsize);
+    ssize_t result = write(stream->_fd, stream->_buf.buffer, stream->_buf.size);
 
-    stream->_bufindex = 0;
-    stream->_bufsize = 0;
+    stream->_buf.index = 0;
+    stream->_buf.size = 0;
+
+    stream->_buf.status &= ~FileStatusFlags::LastWrite;
 
     return result < 0 ? EOF : 0;
 }
 
+static int flush_read_buffer(FILE* stream)
+{
+    if (stream->_buf.mode == _IONBF) return 0;
+
+    // Reset the stream to its expected position.
+    ssize_t unread_bytes = stream->_buf.size - stream->_buf.index;
+    lseek(stream->_fd, -unread_bytes, SEEK_CUR);
+
+    stream->_buf.index = 0;
+    stream->_buf.size = 0;
+
+    stream->_buf.status &= ~FileStatusFlags::LastRead;
+
+    return 0;
+}
+
 static ssize_t write_into_buffer(FILE* stream, const u8* data, ssize_t size)
 {
     ssize_t total_written = 0;
@@ -74,20 +97,24 @@ static ssize_t write_into_buffer(FILE* stream, const u8* data, ssize_t size)
     while (size > 0)
     {
         ssize_t nwritten;
-        if (stream->_mode != _IONBF)
+        if (stream->_buf.mode != _IONBF)
         {
-            if ((stream->_bufsize + size) > stream->_bufcap)
+            if (stream->_buf.status & FileStatusFlags::LastRead) flush_read_buffer(stream);
+
+            if ((stream->_buf.size + size) > stream->_buf.capacity)
             {
                 if (flush_write_buffer(stream) < 0) return -1;
             }
 
-            ssize_t size_remaining = stream->_bufcap - stream->_bufsize;
+            ssize_t size_remaining = stream->_buf.capacity - stream->_buf.size;
             nwritten = size > size_remaining ? size_remaining : size;
-            memcpy(stream->_buffer + stream->_bufsize, data, nwritten);
+            memcpy(stream->_buf.buffer + stream->_buf.size, data, nwritten);
 
-            stream->_bufsize += nwritten;
+            stream->_buf.status |= FileStatusFlags::LastWrite;
 
-            if (stream->_mode == _IOLBF && memchr(data, '\n', nwritten))
+            stream->_buf.size += nwritten;
+
+            if (stream->_buf.mode == _IOLBF && memchr(data, '\n', nwritten))
             {
                 if (flush_write_buffer(stream) < 0) return -1;
             }
@@ -103,6 +130,51 @@ static ssize_t write_into_buffer(FILE* stream, const u8* data, ssize_t size)
     return total_written;
 }
 
+static ssize_t read_data_into_buffer(FILE* stream)
+{
+    stream->_buf.index = 0;
+    ssize_t nread = read(stream->_fd, stream->_buf.buffer, stream->_buf.capacity);
+    if (nread >= 0) stream->_buf.size = nread;
+    stream->_buf.status |= FileStatusFlags::LastRead;
+    return nread;
+}
+
+static ssize_t read_from_buffer(FILE* stream, u8* data, ssize_t size)
+{
+    ssize_t total_read = 0;
+
+    while (size > 0)
+    {
+        ssize_t nread;
+        if (stream->_buf.mode != _IONBF)
+        {
+            if (stream->_buf.status & FileStatusFlags::LastWrite) flush_write_buffer(stream);
+
+            if (stream->_buf.size == stream->_buf.index)
+            {
+                ssize_t rc;
+                if ((rc = read_data_into_buffer(stream)) < 0) return -1;
+                if (rc == 0) return total_read;
+            }
+
+            ssize_t size_remaining = stream->_buf.size - stream->_buf.index;
+            nread = size > size_remaining ? size_remaining : size;
+            memcpy(data, stream->_buf.buffer + stream->_buf.index, nread);
+
+            stream->_buf.index += nread;
+        }
+        else
+            nread = read(stream->_fd, data, size > BUFSIZ ? BUFSIZ : size);
+        if (nread < 0) return nread;
+        if (nread == 0) return total_read;
+        size -= nread;
+        data += nread;
+        total_read += nread;
+    }
+
+    return total_read;
+}
+
 extern "C"
 {
     void _init_stdio()
@@ -112,7 +184,12 @@ extern "C"
 
     int fflush(FILE* stream)
     {
-        if (stream && stream->_mode != _IONBF) flush_write_buffer(stream);
+        if (stream && stream->_buf.mode != _IONBF)
+        {
+            if (stream->_buf.status & FileStatusFlags::LastWrite) flush_write_buffer(stream);
+            else if (stream->_buf.status & FileStatusFlags::LastRead)
+                flush_read_buffer(stream);
+        }
         else if (!stream)
         {
             for (int i = 0; i < FOPEN_MAX; i++)
@@ -142,12 +219,12 @@ extern "C"
         f->_fd = fd;
         clearerr(f);
 
-        f->_pending = 0;
         f->_flags = flags;
-        f->_mode = isatty(fd) ? _IOLBF : _IOFBF;
-        f->_bufsize = f->_bufindex = 0;
-        f->_buffer = nullptr;
-        setvbuf(f, NULL, f->_mode, 0);
+        f->_buf.status = 0;
+        f->_buf.mode = isatty(fd) ? _IOLBF : _IOFBF;
+        f->_buf.size = f->_buf.index = 0;
+        f->_buf.buffer = nullptr;
+        setvbuf(f, NULL, f->_buf.mode, 0);
 
         s_open_files[fd] = f;
 
@@ -168,12 +245,12 @@ extern "C"
         f->_fd = fd;
         clearerr(f);
 
-        f->_pending = 0;
         f->_flags = flags;
-        f->_mode = buffering_mode < 0 ? (isatty(fd) ? _IOLBF : _IOFBF) : buffering_mode;
-        f->_bufsize = f->_bufindex = 0;
-        f->_buffer = nullptr;
-        setvbuf(f, NULL, f->_mode, 0);
+        f->_buf.status = 0;
+        f->_buf.mode = buffering_mode < 0 ? (isatty(fd) ? _IOLBF : _IOFBF) : buffering_mode;
+        f->_buf.size = f->_buf.index = 0;
+        f->_buf.buffer = nullptr;
+        setvbuf(f, NULL, f->_buf.mode, 0);
 
         s_open_files[fd] = f;
 
@@ -195,7 +272,7 @@ extern "C"
 
         s_open_files[stream->_fd] = nullptr;
 
-        if (stream->_buffer && (stream->_pending & FFLAG_FREE_AFTER_BUFFER_USE)) free(stream->_buffer);
+        if (stream->_buf.buffer && (stream->_buf.status & FileStatusFlags::BufferIsMalloced)) free(stream->_buf.buffer);
 
         if (!path) { fail("FIXME: freopen() called with path=nullptr"); }
 
@@ -205,12 +282,12 @@ extern "C"
         stream->_fd = fd;
         clearerr(stream);
 
-        stream->_pending = 0;
         stream->_flags = flags;
-        stream->_mode = isatty(fd) ? _IOLBF : _IOFBF;
-        stream->_bufsize = stream->_bufindex = 0;
-        stream->_buffer = nullptr;
-        setvbuf(stream, NULL, stream->_mode, 0);
+        stream->_buf.status = 0;
+        stream->_buf.mode = isatty(fd) ? _IOLBF : _IOFBF;
+        stream->_buf.size = stream->_buf.index = 0;
+        stream->_buf.buffer = nullptr;
+        setvbuf(stream, NULL, stream->_buf.mode, 0);
 
         s_open_files[fd] = stream;
 
@@ -223,7 +300,7 @@ extern "C"
 
         if (close(stream->_fd) < 0) return EOF;
 
-        if (stream->_buffer && (stream->_pending & FFLAG_FREE_AFTER_BUFFER_USE)) free(stream->_buffer);
+        if (stream->_buf.buffer && (stream->_buf.status & FileStatusFlags::BufferIsMalloced)) free(stream->_buf.buffer);
 
         s_open_files[stream->_fd] = nullptr;
 
@@ -241,7 +318,7 @@ extern "C"
     {
         if (size * nmemb == 0) return 0;
 
-        ssize_t nread = read(stream->_fd, buf, size * nmemb);
+        ssize_t nread = read_from_buffer(stream, (u8*)buf, size * nmemb);
 
         if (nread < 0)
         {
@@ -273,6 +350,8 @@ extern "C"
 
     int fseek(FILE* stream, long offset, int whence)
     {
+        fflush(stream);
+
         long result = lseek(stream->_fd, offset, whence);
         if (result < 0) return -1;
 
@@ -284,11 +363,15 @@ extern "C"
 
     long ftell(FILE* stream)
     {
+        fflush(stream);
+
         return lseek(stream->_fd, 0, SEEK_CUR);
     }
 
     void rewind(FILE* stream)
     {
+        fflush(stream);
+
         lseek(stream->_fd, 0, SEEK_SET);
 
         clearerr(stream);
@@ -306,6 +389,8 @@ extern "C"
 
     int fsetpos(FILE* stream, const fpos_t* pos)
     {
+        fflush(stream);
+
         return fseek(stream, *pos, SEEK_SET);
     }
 
@@ -346,7 +431,7 @@ extern "C"
     int fgetc(FILE* stream)
     {
         u8 value;
-        ssize_t rc = read(stream->_fd, &value, 1);
+        ssize_t rc = read_from_buffer(stream, &value, 1);
         if (rc <= 0) return EOF;
         return value;
     }
@@ -603,35 +688,44 @@ extern "C"
         return f;
     }
 
-    int ungetc(int, FILE*)
+    int ungetc(int c, FILE* stream)
     {
-        fail("FIXME: ungetc: not implemented");
+        if (stream->_buf.index == 0)
+            return EOF; // No data currently in the read buffer, or no data has been read from it.
+
+        if (stream->_buf.mode == _IONBF)
+            return EOF; // FIXME: C doesn't state that ungetc() should only work on buffered streams.
+
+        stream->_buf.index--;
+        stream->_buf.buffer[stream->_buf.index] = (char)c;
+
+        return 0;
     }
 
     int setvbuf(FILE* stream, char* buf, int mode, size_t size)
     {
-        int pending = 0;
+        int status = 0;
         if (mode < 0 || mode > _IOFBF) return errno = EINVAL, -1;
-        if (stream->_bufsize != 0 || stream->_bufindex != 0) return -1; // Buffer is already in use.
+        if (stream->_buf.size != 0 || stream->_buf.index != 0) return -1; // Buffer is already in use.
         if (mode != _IONBF && buf == NULL)
         {
             size = BUFSIZ;
             buf = (char*)calloc(size, 1);
             if (!buf) return -1;
-            pending = FFLAG_FREE_AFTER_BUFFER_USE;
+            status = FileStatusFlags::BufferIsMalloced;
         }
-        else
+        else if (mode == _IONBF)
         {
             buf = NULL;
             size = 0;
         }
 
-        if (stream->_buffer && (stream->_pending & FFLAG_FREE_AFTER_BUFFER_USE)) free(stream->_buffer);
+        if (stream->_buf.buffer && (stream->_buf.status & FileStatusFlags::BufferIsMalloced)) free(stream->_buf.buffer);
 
-        stream->_buffer = buf;
-        stream->_bufcap = size;
-        stream->_mode = mode;
-        stream->_pending = pending;
+        stream->_buf.buffer = buf;
+        stream->_buf.capacity = size;
+        stream->_buf.mode = mode;
+        stream->_buf.status = status;
 
         return 0;
     }