[mycpp] POSIX I/O experiment

Signed-off-by: Andrii Sultanov <[email protected]>

Author: last-genius

cpp/stdlib.cc

@@ -70,20 +70,13 @@ void putenv(BigStr* name, BigStr* value) {
 
 mylib::File* fdopen(int fd, BigStr* c_mode) {
   // CPython checks if it's a directory first
+
   struct stat buf;
   if (fstat(fd, &buf) == 0 && S_ISDIR(buf.st_mode)) {
     throw Alloc<OSError>(EISDIR);
   }
 
-  // CPython does some fcntl() stuff with mode == 'a', which we don't support
-  DCHECK(c_mode->data_[0] != 'a');
-
-  FILE* f = ::fdopen(fd, c_mode->data_);
-  if (f == nullptr) {
-    throw Alloc<OSError>(errno);
-  }
-
-  return Alloc<mylib::CFile>(f);
+  return Alloc<mylib::CFile>(fd);
 }
 
 void execve(BigStr* argv0, List<BigStr*>* argv,

mycpp/gc_mylib.cc

@@ -1,6 +1,7 @@
 #include "mycpp/gc_mylib.h"
 
 #include <errno.h>
+#include <fcntl.h>
 #include <math.h>
 #include <stdio.h>
 #include <unistd.h>  // isatty
@@ -104,51 +105,58 @@ Tuple2<BigStr*, BigStr*> split_once(BigStr* s, BigStr* delim) {
 LineReader* gStdin;
 
 LineReader* open(BigStr* path) {
-  // TODO: Don't use C I/O; use POSIX I/O!
-  FILE* f = fopen(path->data_, "r");
-  if (f == nullptr) {
+  int fd = ::open(path->data_, O_RDONLY);
+
+  if (fd < 0) {
     throw Alloc<IOError>(errno);
   }
 
-  return reinterpret_cast<LineReader*>(Alloc<CFile>(f));
+  return reinterpret_cast<LineReader*>(Alloc<CFile>(fd));
 }
 
 BigStr* CFile::readline() {
-  char* line = nullptr;
-  size_t allocated_size = 0;  // unused
-
   // Reset errno because we turn the EOF error into empty string (like Python).
   errno = 0;
-  ssize_t len = getline(&line, &allocated_size, f_);
-  // log("getline = %d", len);
-  if (len < 0) {
-    // Reset EOF flag so the next readline() will get a line.
-    clearerr(f_);
-
-    // man page says the buffer should be freed even if getline fails
-    free(line);
-
-    // Raise KeyboardInterrupt like mylib.Stdin().readline() does in Python!
-    // This affects _PlainPromptInput() in frontend/reader.py.
-    if (errno == EINTR && iolib::gSignalSafe->PollUntrappedSigInt()) {
-      throw Alloc<KeyboardInterrupt>();
-    }
 
-    if (errno != 0) {  // Unexpected error
-      // log("getline() error: %s", strerror(errno));
-      throw Alloc<IOError>(errno);
-    }
-    return kEmptyString;  // Indicate EOF with empty string, like Python
+  size_t i = 0;
+  bool null_terminated = false;
+  for (; i < 131071; i++) {
+      ssize_t len = read(fd_, &(line_[i]), 1);
+      if (len == 0) {
+        line_[i] = '\0';
+        null_terminated = true;
+        break;
+      } else if (line_[i] == '\n') {
+        line_[i+1] = '\0';
+        i++;
+        null_terminated = true;
+        break;
+      } else if (line_[i] == '\0') {
+        null_terminated = true;
+        break;
+      } else if (len < 0) {
+        // Raise KeyboardInterrupt like mylib.Stdin().readline() does in Python!
+        // This affects _PlainPromptInput() in frontend/reader.py.
+        if (errno == EINTR && iolib::gSignalSafe->PollUntrappedSigInt()) {
+          throw Alloc<KeyboardInterrupt>();
+        }
+
+        if (errno != 0) {  // Unexpected error
+          throw Alloc<IOError>(errno);
+        }
+        return kEmptyString;  // Indicate EOF with empty string, like Python
+      }
   }
+  if (!null_terminated)
+      throw Alloc<IOError>(-1); // Line too long, didn't reach the newline char
+
+  BigStr* result = ::StrFromC(line_, i);
 
-  // Note: getline() NUL-terminates the buffer
-  BigStr* result = ::StrFromC(line, len);
-  free(line);
   return result;
 }
 
 bool CFile::isatty() {
-  return ::isatty(fileno(f_));
+  return ::isatty(fd_);
 }
 
 // Problem: most BigStr methods like index() and slice() COPY so they have a
@@ -197,21 +205,19 @@ Writer* gStderr;
 void CFile::write(BigStr* s) {
   // Writes can be short!
   int n = len(s);
-  int num_written = ::fwrite(s->data_, sizeof(char), n, f_);
+  int num_written = ::write(fd_, s->data_, n);
   // Similar to CPython fileobject.c
   if (num_written != n) {
     throw Alloc<IOError>(errno);
   }
 }
 
 void CFile::flush() {
-  if (::fflush(f_) != 0) {
-    throw Alloc<IOError>(errno);
-  }
+  // no-op for now
 }
 
 void CFile::close() {
-  if (::fclose(f_) != 0) {
+  if (::close(fd_) != 0) {
     throw Alloc<IOError>(errno);
   }
 }

mycpp/gc_mylib.h

@@ -9,6 +9,7 @@
 #include "mycpp/gc_tuple.h"
 
 #include <sys/stat.h>
+#include <unistd.h>
 
 template <class K, class V>
 class Dict;
@@ -155,7 +156,7 @@ class File {
 // Wrap a FILE* for read and write
 class CFile : public File {
  public:
-  explicit CFile(FILE* f) : File(), f_(f) {
+  explicit CFile(int fd) : File(), fd_(fd) {
   }
   // Writer
   void write(BigStr* s) override;
@@ -178,7 +179,8 @@ class CFile : public File {
   }
 
  private:
-  FILE* f_;
+  int fd_;
+  char line_[131072];
 
   DISALLOW_COPY_AND_ASSIGN(CFile)
 };
@@ -234,7 +236,7 @@ extern LineReader* gStdin;
 
 inline LineReader* Stdin() {
   if (gStdin == nullptr) {
-    gStdin = reinterpret_cast<LineReader*>(Alloc<CFile>(stdin));
+    gStdin = reinterpret_cast<LineReader*>(Alloc<CFile>(STDIN_FILENO));
   }
   return gStdin;
 }
@@ -331,7 +333,7 @@ extern Writer* gStdout;
 
 inline Writer* Stdout() {
   if (gStdout == nullptr) {
-    gStdout = reinterpret_cast<Writer*>(Alloc<CFile>(stdout));
+    gStdout = reinterpret_cast<Writer*>(Alloc<CFile>(STDOUT_FILENO));
     gHeap.RootGlobalVar(gStdout);
   }
   return gStdout;
@@ -341,7 +343,7 @@ extern Writer* gStderr;
 
 inline Writer* Stderr() {
   if (gStderr == nullptr) {
-    gStderr = reinterpret_cast<Writer*>(Alloc<CFile>(stderr));
+    gStderr = reinterpret_cast<Writer*>(Alloc<CFile>(STDERR_FILENO));
     gHeap.RootGlobalVar(gStderr);
   }
   return gStderr;

mycpp/gc_mylib_test.cc

@@ -1,6 +1,7 @@
 #include "mycpp/gc_mylib.h"
 
 #include <unistd.h>
+#include <fcntl.h>
 
 #include "mycpp/gc_alloc.h"  // gHeap
 #include "mycpp/gc_str.h"
@@ -219,14 +220,14 @@ TEST files_test() {
   mylib::LineReader* stdin_ = mylib::Stdin();
   log("stdin isatty() = %d", stdin_->isatty());
 
-  FILE* f = fopen("README.md", "r");
+  int fd = open("README.md", O_RDONLY);
 
   mylib::CFile* r = nullptr;
   BigStr* filename = nullptr;
   BigStr* filename2 = nullptr;
   StackRoots _roots({&r, &filename, &filename2});
 
-  r = Alloc<mylib::CFile>(f);
+  r = Alloc<mylib::CFile>(fd);
   filename = StrFromC("README.md");
   filename2 = StrFromC("README.md ");
   // auto r = mylib::Stdin();
@@ -254,7 +255,7 @@ TEST files_test() {
   auto f3 = mylib::open(filename2->strip());
   ASSERT(f3 != nullptr);
 
-  auto w = Alloc<mylib::CFile>(stdout);
+  auto w = Alloc<mylib::CFile>(STDOUT_FILENO);
   w->write(StrFromC("stdout"));
   w->flush();