Specialize on most common opening flags (#816)

phischu · b-studios · web-flow · commit 37d11892172a · 2025-02-06T17:12:20.000+01:00
Should fix #809 Please test on Windows and Mac --------- Co-authored-by: Jonathan Brachthäuser <jonathan@b-studios.de>
diff --git a/examples/stdlib/io/filesystem/write_read_append.check b/examples/stdlib/io/filesystem/write_read_append.check
@@ -0,0 +1,2 @@
+hello!
+hello! world!
diff --git a/examples/stdlib/io/filesystem/write_read_append.effekt b/examples/stdlib/io/filesystem/write_read_append.effekt
@@ -0,0 +1,42 @@
+import io
+import io/filesystem
+import io/error
+
+import bytearray
+
+def writeHello(path: String) =  {
+  val file = openForWriting(path)
+  val buffer = fromString("hello!")
+  val n = file.write(buffer, 0, buffer.size, 0)
+  if (n < buffer.size) {
+    panic("write failed")
+  }
+  file.close()
+}
+
+def readContents(path: String) = {
+  val file = openForReading(path)
+  val buffer = bytearray::allocate(64)
+  val n = file.read(buffer, 0, buffer.size, 0)
+  file.close()
+  buffer.resize(n).toString
+}
+
+def appendWorld(path: String) =  {
+  val file = openForAppending(path)
+  val buffer = fromString(" world!")
+  val n = file.write(buffer, 0, buffer.size, -1)
+  if (n < buffer.size) {
+    panic("append failed")
+  }
+  file.close()
+}
+
+def main() = {
+  with on[IOError].panic;
+  val filename = "/tmp/some_file_to_write.txt"
+  writeHello(filename)
+  println(readContents(filename))
+  appendWorld(filename)
+  println(readContents(filename))
+}
diff --git a/libraries/common/io/filesystem.effekt b/libraries/common/io/filesystem.effekt
@@ -6,35 +6,13 @@ import io
 import io/error
 
 
-/// Represents the file opening modes with their respective flags
-/// Backends rely on the order of these
-type Mode {
-  // Most common modes
-  ReadOnly()            // 'r'  exception if does not exist
-  WriteOnly()           // 'w'  created if does not exist, truncated if exists
-  AppendOnly()          // 'a'  created if does not exist
-
-  // Other modes
-  ReadWrite()           // 'w+' created if does not exist, truncated if exists
-  ReadAppend()          // 'a+' created if does not exist
-  AppendExclusive()     // 'ax' created if does not exist, fails if exists
-  ReadAppendExclusive() // 'ax+' created if does not exist, fails if exists
-  AppendSync()          // 'as' created if does not exist, append in synchronous mode
-  ReadAppendSync()      // 'as+' created if does not exist, append in synchronous mode
-  ReadSync()            // 'rs' exception if does not exist, read in synchronous mode
-  ReadWriteSync()       // 'rs+' exception if does not exist, read/write in synchronous mode
-  WriteExclusive()      // 'wx' created if does not exist, truncated if exists, fails if exists
-  ReadWriteExclusive()  // 'wx+' created if does not exist, truncated if exists, fails if exists
-}
-
-
 /// A file descriptor. Should not be inspected.
 type File = Int
 
 
 /// Reads a file at given path as utf8 encoded string.
 def readFile(path: String): String / Exception[IOError] = {
-  val file = open(path, ReadOnly());
+  val file = openForReading(path);
   with on[IOError].finalize { close(file) }
 
   val chunkSize = 1048576 // 1MB
@@ -59,7 +37,7 @@ def readFile(path: String): String / Exception[IOError] = {
 
 /// Writes the (utf8 encoded) string `contents` into the specified file.
 def writeFile(path: String, contents: String): Unit / Exception[IOError] = {
-  val file = open(path, WriteOnly());
+  val file = openForWriting(path);
   with on[IOError].finalize { close(file) }
 
   val chunkSize = 1048576 // 1MB
@@ -75,6 +53,23 @@ def writeFile(path: String, contents: String): Unit / Exception[IOError] = {
   go()
 }
 
+/// Appends the (utf8 encoded) string `contents` to the specified file.
+def appendFile(path: String, contents: String): Unit / Exception[IOError] = {
+  val file = openForAppending(path);
+  with on[IOError].finalize { close(file) }
+
+  val chunkSize = 1048576 // 1MB
+  val buffer = contents.fromString
+  var offset = 0;
+
+  def go(): Unit = {
+    val n = write(file, buffer, offset, min(buffer.size - offset, chunkSize), -1)
+    offset = offset + n
+    if (offset < buffer.size) { go() }
+  }
+
+  go()
+}
 
 /// An abstract interface applications can program against.
 ///
@@ -95,8 +90,14 @@ def filesystem[R] { program: => R / Files }: R / Exception[IOError] = // TODO mo
   }
 
 
-def open(path: String, mode: Mode): File / Exception[IOError] =
-  internal::checkResult(internal::open(path, mode))
+def openForReading(path: String): File / Exception[IOError] =
+  internal::checkResult(internal::openForReading(path))
+
+def openForWriting(path: String): File / Exception[IOError] =
+  internal::checkResult(internal::openForWriting(path))
+
+def openForAppending(path: String): File / Exception[IOError] =
+  internal::checkResult(internal::openForAppending(path))
 
 def read(file: File, buffer: ByteArray, offset: Int, size: Int, position: Int): Int / Exception[IOError] =
   internal::checkResult(internal::read(file, buffer, offset, size, position))
@@ -111,40 +112,6 @@ def close(file: File): Unit / Exception[IOError] = {
 namespace internal {
 
   extern js """
-    function modeName(mode) {
-      switch (mode.__tag) {
-      case 0: // ReadOnly()
-        return 'r';
-      case 1: // WriteOnly()
-        return 'w';
-      case 2: // AppendOnly()
-        return 'a';
-      case 3: // ReadWrite()
-        return 'w+';
-      case 4: // ReadAppend()
-        return 'a+';
-      case 5: // AppendExclusive()
-        return 'ax';
-      case 6: // ReadAppendExclusive()
-        return 'ax+';
-      case 7: // AppendSync()
-        return 'as';
-      case 8: // ReadAppendSync()
-        return 'as+';
-      case 9: // ReadSync()
-        return 'rs';
-      case 10: // ReadWriteSync()
-        return 'rs+';
-      case 11: // WriteExclusive()
-        return 'wx';
-      case 12: // ReadWriteExclusive()
-        return 'wx+';
-      default:
-        // Invalid tag value
-        return null;
-      }
-    }
-
     /**
      * Nodejs file operations expect buffers, but we represent buffers as typed arrays.
      * This function converts between the two without copying.
@@ -157,8 +124,8 @@ namespace internal {
   extern jsNode """
     const fs = require("fs");
 
-    function open(path, mode, callback) {
-      fs.open(path, modeName(mode), (err, file) => {
+    function open(path, flags, callback) {
+      fs.open(path, flags, (err, file) => {
         if (err) { callback(err.errno) } else { callback(file) }
       })
     }
@@ -185,16 +152,32 @@ namespace internal {
   """
 
   extern llvm """
-    declare void @c_fs_open(%Pos, %Pos, %Stack)
+    declare void @c_fs_open_reading(%Pos, %Stack)
+    declare void @c_fs_open_writing(%Pos, %Stack)
+    declare void @c_fs_open_appending(%Pos, %Stack)
     declare void @c_fs_read(%Int, %Pos, %Int, %Int, %Int, %Stack)
     declare void @c_fs_write(%Int, %Pos, %Int, %Int, %Int, %Stack)
     declare void @c_fs_close(%Int, %Stack)
   """
 
-  extern async def open(path: String, mode: Mode): Int =
-    jsNode "$effekt.capture(callback => open(${path}, ${mode}, callback))"
+  extern async def openForReading(path: String): Int =
+    jsNode "$effekt.capture(callback => open(${path}, 'r', callback))"
+    llvm """
+      call void @c_fs_open_reading(%Pos ${path}, %Stack %stack)
+      ret void
+    """
+
+  extern async def openForWriting(path: String): Int =
+    jsNode "$effekt.capture(callback => open(${path}, 'w', callback))"
+    llvm """
+      call void @c_fs_open_writing(%Pos ${path}, %Stack %stack)
+      ret void
+    """
+
+  extern async def openForAppending(path: String): Int =
+    jsNode "$effekt.capture(callback => open(${path}, 'a', callback))"
     llvm """
-      call void @c_fs_open(%Pos ${path}, %Pos ${mode}, %Stack %stack)
+      call void @c_fs_open_appending(%Pos ${path}, %Stack %stack)
       ret void
     """
 
diff --git a/libraries/common/stream.effekt b/libraries/common/stream.effekt
@@ -263,7 +263,7 @@ def zip[A, B] { stream1: () => Unit / emit[A] } { stream2: () => Unit / emit[B]
 
 def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[IOError] = {
 
-  val file = open(path, WriteOnly());
+  val file = openForWriting(path);
   with on[IOError].finalize { close(file) }
 
   val chunkSize = 1048576 // 1MB
@@ -291,7 +291,7 @@ def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[I
 
 def readFile[R](path: String) { reader: () => R / read[Byte] }: R / Exception[IOError] = {
 
-  val file = open(path, ReadOnly());
+  val file = openForReading(path);
   with on[IOError].finalize { close(file) }
 
   val chunkSize = 1048576 // 1MB
diff --git a/libraries/llvm/io.c b/libraries/llvm/io.c
@@ -62,50 +62,12 @@ void c_resume_int_fs(uv_fs_t* request) {
     resume_Int(stack, result);
 }
 
-int modeFlags(struct Pos mode) {
-    switch (mode.tag) {
-        case 0: // ReadOnly()
-            return UV_FS_O_RDONLY;
-        case 1: // WriteOnly()
-            return UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_TRUNC;
-        case 2: // AppendOnly()
-            return UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_APPEND;
-        case 3: // ReadWrite()
-            return UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_TRUNC;
-        case 4: // ReadAppend()
-            return UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_APPEND;
-        case 5: // AppendExclusive()
-            return UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_APPEND | UV_FS_O_EXCL;
-        case 6: // ReadAppendExclusive()
-            return UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_APPEND | UV_FS_O_EXCL;
-        case 7: // AppendSync()
-            return UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_APPEND | UV_FS_O_SYNC;
-        case 8: // ReadAppendSync()
-            return UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_APPEND | UV_FS_O_SYNC;
-        case 9: // ReadSync()
-            return UV_FS_O_RDONLY | UV_FS_O_SYNC;
-        case 10: // ReadWriteSync()
-            return UV_FS_O_RDWR | UV_FS_O_SYNC;
-        case 11: // WriteExclusive()
-            return UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_TRUNC | UV_FS_O_EXCL;
-        case 12: // ReadWriteExclusive()
-            return UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_TRUNC | UV_FS_O_EXCL;
-        default:
-            // Invalid tag value
-            return -1;
-    }
-}
-
-void c_fs_open(String path, struct Pos mode, Stack stack) {
+void c_fs_open(String path, int flags, Stack stack) {
 
     // Convert the Effekt String to a 0-terminated string
     char* path_str = c_bytearray_into_nullterminated_string(path);
     erasePositive((struct Pos) path);
 
-    // Convert the Effekt String representing the opening mode to libuv flags
-    int flags = modeFlags(mode);
-    erasePositive((struct Pos) mode);
-
     uv_fs_t* request = malloc(sizeof(uv_fs_t));
     request->data = stack;
 
@@ -123,6 +85,18 @@ void c_fs_open(String path, struct Pos mode, Stack stack) {
     return;
 }
 
+void c_fs_open_reading(String path, Stack stack) {
+    c_fs_open(path, UV_FS_O_RDONLY, stack);
+}
+
+void c_fs_open_writing(String path, Stack stack) {
+    c_fs_open(path, UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_TRUNC, stack);
+}
+
+void c_fs_open_appending(String path, Stack stack) {
+    c_fs_open(path, UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_APPEND, stack);
+}
+
 void c_fs_read(Int file, struct Pos buffer, Int offset, Int size, Int position, Stack stack) {
 
     uv_buf_t buf = uv_buf_init((char*)(c_bytearray_data(buffer) + offset), size);
