Refactor File to store error_code instead of error flag

Author: mleleszi

libc/src/__support/File/file.cpp

@@ -20,7 +20,7 @@ namespace LIBC_NAMESPACE_DECL {
 
 FileIOResult File::write_unlocked(const void *data, size_t len) {
   if (!write_allowed()) {
-    err = true;
+    error_code = EBADF;
     return {0, EBADF};
   }
 
@@ -45,16 +45,16 @@ FileIOResult File::write_unlocked_nbf(const uint8_t *data, size_t len) {
     FileIOResult write_result = platform_write(this, buf, write_size);
     pos = 0; // Buffer is now empty so reset pos to the beginning.
     // If less bytes were written than expected, then an error occurred.
-    if (write_result < write_size) {
-      err = true;
+    if (write_result.has_error() || write_result < write_size) {
+      error_code = write_result.has_error() ? write_result.error : EIO;
       // No bytes from data were written, so return 0.
-      return {0, write_result.error};
+      return {0, error_code};
     }
   }
 
   FileIOResult write_result = platform_write(this, data, len);
-  if (write_result < len)
-    err = true;
+  if (write_result.has_error() || write_result < len)
+    error_code = write_result.has_error() ? write_result.error : EIO;
   return write_result;
 }
 
@@ -106,9 +106,9 @@ FileIOResult File::write_unlocked_fbf(const uint8_t *data, size_t len) {
   // If less bytes were written than expected, then an error occurred. Return
   // the number of bytes that have been written from |data|.
   if (buf_result.has_error() || bytes_written < write_size) {
-    err = true;
+    error_code = buf_result.has_error() ? buf_result.error : EIO;
     return {bytes_written <= init_pos ? 0 : bytes_written - init_pos,
-            buf_result.error};
+            error_code};
   }
 
   // The second piece is handled basically the same as the first, although we
@@ -128,8 +128,8 @@ FileIOResult File::write_unlocked_fbf(const uint8_t *data, size_t len) {
     // If less bytes were written than expected, then an error occurred. Return
     // the number of bytes that have been written from |data|.
     if (result.has_error() || bytes_written < remainder.size()) {
-      err = true;
-      return {primary.size() + bytes_written, result.error};
+      error_code = result.has_error() ? result.error : EIO;
+      return {primary.size() + bytes_written, error_code};
     }
   }
 
@@ -166,26 +166,28 @@ FileIOResult File::write_unlocked_lbf(const uint8_t *data, size_t len) {
 
   size_t written = 0;
 
-  written = write_unlocked_nbf(primary.data(), primary.size());
-  if (written < primary.size()) {
-    err = true;
-    return written;
+  auto write_result = write_unlocked_nbf(primary.data(), primary.size());
+  written += write_result;
+  if (write_result.has_error() || written < primary.size()) {
+    error_code = write_result.has_error() ? write_result.error : EIO;
+    return {written, error_code};
   }
 
   flush_unlocked();
 
-  written += write_unlocked_fbf(remainder.data(), remainder.size());
-  if (written < len) {
-    err = true;
-    return written;
+  write_result = write_unlocked_fbf(remainder.data(), remainder.size());
+  written += write_result;;
+  if (write_result.has_error() || written < len) {
+    error_code = write_result.has_error() ? write_result.error : EIO;
+    return {written, error_code};
   }
 
   return len;
 }
 
 FileIOResult File::read_unlocked(void *data, size_t len) {
   if (!read_allowed()) {
-    err = true;
+    error_code = EBADF;
     return {0, EBADF};
   }
 
@@ -244,7 +246,7 @@ FileIOResult File::read_unlocked_fbf(uint8_t *data, size_t len) {
       if (!result.has_error())
         eof = true;
       else
-        err = true;
+        error_code = result.error;
       return {available_data + fetched_size, result.error};
     }
     return len;
@@ -262,7 +264,7 @@ FileIOResult File::read_unlocked_fbf(uint8_t *data, size_t len) {
     if (!result.has_error())
       eof = true;
     else
-      err = true;
+      error_code = result.error;
   }
   return {transfer_size + available_data, result.error};
 }
@@ -282,7 +284,7 @@ FileIOResult File::read_unlocked_nbf(uint8_t *data, size_t len) {
     if (!result.has_error())
       eof = true;
     else
-      err = true;
+      error_code = result.error;
   }
   return {result + available_data, result.error};
 }
@@ -321,7 +323,7 @@ int File::ungetc_unlocked(int c) {
   }
 
   eof = false; // There is atleast one character that can be read now.
-  err = false; // This operation was a success.
+  error_code = 0; // This operation was a success.
   return c;
 }
 
@@ -331,8 +333,8 @@ ErrorOr<int> File::seek(off_t offset, int whence) {
 
     FileIOResult buf_result = platform_write(this, buf, pos);
     if (buf_result.has_error() || buf_result.value < pos) {
-      err = true;
-      return Error(buf_result.error);
+      error_code = buf_result.has_error() ? buf_result.error : EIO;
+      return Error(error_code);
     }
   } else if (prev_op == FileOp::READ && whence == SEEK_CUR) {
     // More data could have been read out from the platform file than was
@@ -369,8 +371,8 @@ int File::flush_unlocked() {
   if (prev_op == FileOp::WRITE && pos > 0) {
     FileIOResult buf_result = platform_write(this, buf, pos);
     if (buf_result.has_error() || buf_result.value < pos) {
-      err = true;
-      return buf_result.error;
+      error_code = buf_result.has_error() ? buf_result.error : EIO;
+      return error_code;
     }
     pos = 0;
   }

libc/src/__support/File/file.h

@@ -118,7 +118,7 @@ class File {
   size_t read_limit;
 
   bool eof;
-  bool err;
+  int error_code;
 
   // This is a convenience RAII class to lock and unlock file objects.
   class FileLock {
@@ -161,7 +161,7 @@ class File {
                                   /*robust=*/false, /*pshared=*/false),
         ungetc_buf(0), buf(buffer), bufsize(buffer_size), bufmode(buffer_mode),
         own_buf(owned), mode(modeflags), pos(0), prev_op(FileOp::NONE),
-        read_limit(0), eof(false), err(false) {
+        read_limit(0), eof(false), error_code(0) {
     adjust_buf();
   }
 
@@ -214,8 +214,8 @@ class File {
       if (prev_op == FileOp::WRITE && pos > 0) {
         auto buf_result = platform_write(this, buf, pos);
         if (buf_result.has_error() || buf_result.value < pos) {
-          err = true;
-          return buf_result.error;
+          error_code = buf_result.has_error() ? buf_result.error : EIO;
+          return error_code;
         }
       }
     }
@@ -250,14 +250,14 @@ class File {
   void lock() { mutex.lock(); }
   void unlock() { mutex.unlock(); }
 
-  bool error_unlocked() const { return err; }
+  bool error_unlocked() const { return error_code != 0; }
 
   bool error() {
     FileLock l(this);
     return error_unlocked();
   }
 
-  void clearerr_unlocked() { err = false; }
+  void clearerr_unlocked() { error_code = 0; }
 
   void clearerr() {
     FileLock l(this);