@shd101wyy/yo 0.0.23 → 0.0.25

package/std/sys/bufio/buf_reader.yo

@@ -0,0 +1,300 @@
+// std/sys/bufio/buf_reader.yo - Buffered reader for file descriptors
+//
+// Wraps a file descriptor with an internal buffer for efficient reads.
+// Reduces the number of system calls by reading data in larger chunks.
+//
+// Example:
+//   { BufReader } :: import "std/sys/bufio/buf_reader";
+//   IO_file :: import "std/sys/file";
+//
+//   reader := BufReader.new(fd);
+//   line := io.await(reader.read_line(using(io)));
+//   match(line,
+//     .Ok(.Some(s)) => println(s),
+//     .Ok(.None) => println("EOF"),
+//     .Err(e) => println(e.to_string())
+//   );
+
+{ ArrayList } :: import "../../collections/array_list";
+open import "../../string";
+{ IOError } :: import "../errors";
+IO_file :: import "../file";
+{ GlobalAllocator } :: import "../../allocator";
+{ malloc, free } :: GlobalAllocator;
+
+_DEFAULT_BUF_SIZE :: usize(4096);
+_NEWLINE :: u8(10); // '\n'
+
+BufReader :: object(
+  _fd       : i32,
+  _buf      : ArrayList(u8),
+  _pos      : usize,
+  _filled   : usize,
+  _offset   : u64,
+  _capacity : usize
+);
+
+impl(BufReader,
+  // Create a buffered reader with default buffer size (4096 bytes).
+  new : (fn(fd: i32) -> Self)(
+    Self(
+      _fd: fd,
+      _buf: ArrayList(u8).with_capacity(_DEFAULT_BUF_SIZE),
+      _pos: usize(0),
+      _filled: usize(0),
+      _offset: u64(0),
+      _capacity: _DEFAULT_BUF_SIZE
+    )
+  ),
+
+  // Create a buffered reader with a custom buffer size.
+  with_capacity : (fn(fd: i32, capacity: usize) -> Self)(
+    Self(
+      _fd: fd,
+      _buf: ArrayList(u8).with_capacity(capacity),
+      _pos: usize(0),
+      _filled: usize(0),
+      _offset: u64(0),
+      _capacity: capacity
+    )
+  ),
+
+  // Return the underlying file descriptor.
+  fd : (fn(self: Self) -> i32)(
+    self._fd
+  ),
+
+  // Return the number of buffered bytes available to read without I/O.
+  buffered : (fn(self: Self) -> usize)(
+    (self._filled - self._pos)
+  ),
+
+  // Read a line from the reader (up to and including '\n').
+  // Returns .None on EOF when no data is available.
+  // Returns .Some(line) with the line content (without the trailing '\n').
+  read_line : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(Option(String), IOError), IO)))({
+    the_fd := self._fd;
+    io.async((using(io : IO)) => {
+      line_bytes := ArrayList(u8).new();
+      found_newline := false;
+      hit_eof := false;
+      (read_err : Option(IOError)) = .None;
+
+      while runtime((((!(found_newline)) && (!(hit_eof))) && read_err.is_none())), {
+        cond(
+          (self._pos < self._filled) => {
+            scan := self._pos;
+            while runtime(((scan < self._filled) && (!(found_newline)))), {
+              b := self._buf.get(scan).unwrap();
+              cond(
+                (b == _NEWLINE) => {
+                  found_newline = true;
+                },
+                true => {
+                  line_bytes.push(b);
+                }
+              );
+              scan = (scan + usize(1));
+            };
+            self._pos = scan;
+          },
+          true => {
+            raw_buf := *(u8)(malloc(self._capacity).unwrap());
+            n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset));
+            cond(
+              (n < i32(0)) => {
+                free(.Some(*(void)(raw_buf)));
+                read_err = .Some(IOError.from_errno((i32(0) - n)));
+              },
+              (n == i32(0)) => {
+                free(.Some(*(void)(raw_buf)));
+                hit_eof = true;
+              },
+              true => {
+                self._offset = (self._offset + u64(n));
+                self._buf = ArrayList(u8).with_capacity(self._capacity);
+                i := usize(0);
+                while runtime((i < usize(n))), {
+                  self._buf.push((raw_buf &+ i).*);
+                  i = (i + usize(1));
+                };
+                self._pos = usize(0);
+                self._filled = usize(n);
+                free(.Some(*(void)(raw_buf)));
+              }
+            );
+          }
+        );
+      };
+
+      match(read_err,
+        .Some(e) => .Err(e),
+        .None =>
+          cond(
+            (hit_eof && (line_bytes.len() == usize(0))) => .Ok(.None),
+            true => .Ok(.Some(String.from_bytes(line_bytes)))
+          )
+      )
+    })
+  }),
+
+  // Read up to `size` bytes into a provided buffer.
+  // Returns the number of bytes actually read.
+  read : (fn(self: Self, buf: *(u8), size: u32, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))({
+    the_fd := self._fd;
+    io.async((using(io : IO)) => {
+      available := (self._filled - self._pos);
+      (read_err : Option(IOError)) = .None;
+      (read_n : i32) = i32(0);
+      done := false;
+
+      // If there's data already buffered, serve from buffer
+      cond(
+        (available > usize(0)) => {
+          to_copy := cond(
+            (available < usize(size)) => available,
+            true => usize(size)
+          );
+          i := usize(0);
+          while runtime((i < to_copy)), {
+            b := self._buf.get((self._pos + i)).unwrap();
+            (buf &+ i).* = b;
+            i = (i + usize(1));
+          };
+          self._pos = (self._pos + to_copy);
+          read_n = i32(to_copy);
+          done = true;
+        },
+        true => ()
+      );
+
+      // Buffer is empty and large read: bypass buffer
+      cond(
+        ((!(done)) && (usize(size) >= self._capacity)) => {
+          n := io.await(IO_file.read(the_fd, buf, size, self._offset));
+          cond(
+            (n < i32(0)) => {
+              read_err = .Some(IOError.from_errno((i32(0) - n)));
+            },
+            true => {
+              self._offset = (self._offset + u64(n));
+              read_n = n;
+            }
+          );
+          done = true;
+        },
+        true => ()
+      );
+
+      // Buffer is empty and small read: fill buffer first
+      cond(
+        (!(done)) => {
+          raw_buf := *(u8)(malloc(self._capacity).unwrap());
+          n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset));
+          cond(
+            (n < i32(0)) => {
+              free(.Some(*(void)(raw_buf)));
+              read_err = .Some(IOError.from_errno((i32(0) - n)));
+            },
+            (n == i32(0)) => {
+              free(.Some(*(void)(raw_buf)));
+              read_n = i32(0);
+            },
+            true => {
+              self._offset = (self._offset + u64(n));
+              self._buf = ArrayList(u8).with_capacity(self._capacity);
+              i := usize(0);
+              while runtime((i < usize(n))), {
+                self._buf.push((raw_buf &+ i).*);
+                i = (i + usize(1));
+              };
+              self._pos = usize(0);
+              self._filled = usize(n);
+              free(.Some(*(void)(raw_buf)));
+
+              to_copy := cond(
+                (usize(n) < usize(size)) => usize(n),
+                true => usize(size)
+              );
+              j := usize(0);
+              while runtime((j < to_copy)), {
+                b := self._buf.get(j).unwrap();
+                (buf &+ j).* = b;
+                j = (j + usize(1));
+              };
+              self._pos = to_copy;
+              read_n = i32(to_copy);
+            }
+          );
+        },
+        true => ()
+      );
+
+      match(read_err,
+        .Some(e) => .Err(e),
+        .None => .Ok(read_n)
+      )
+    })
+  }),
+
+  // Read all remaining data into an ArrayList of bytes.
+  read_all : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(ArrayList(u8), IOError), IO)))({
+    the_fd := self._fd;
+    io.async((using(io : IO)) => {
+      result := ArrayList(u8).new();
+
+      // First drain any buffered data
+      cond(
+        (self._pos < self._filled) => {
+          i := self._pos;
+          while runtime((i < self._filled)), {
+            result.push(self._buf.get(i).unwrap());
+            i = (i + usize(1));
+          };
+          self._pos = self._filled;
+        },
+        true => ()
+      );
+
+      // Then read the rest from fd
+      raw_buf := *(u8)(malloc(self._capacity).unwrap());
+      (read_err : Option(IOError)) = .None;
+      while runtime(true), {
+        n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset));
+        cond(
+          (n < i32(0)) => {
+            read_err = .Some(IOError.from_errno((i32(0) - n)));
+            break;
+          },
+          (n == i32(0)) => break,
+          true => {
+            self._offset = (self._offset + u64(n));
+            j := usize(0);
+            while runtime((j < usize(n))), {
+              result.push((raw_buf &+ j).*);
+              j = (j + usize(1));
+            };
+          }
+        );
+      };
+      free(.Some(*(void)(raw_buf)));
+      match(read_err,
+        .Some(e) => .Err(e),
+        .None => .Ok(result)
+      )
+    })
+  }),
+
+  // Read all remaining data as a String.
+  read_to_string : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(String, IOError), IO)))(
+    io.async((using(io : IO)) => {
+      bytes_result := io.await(self.read_all(using(io)));
+      match(bytes_result,
+        .Ok(bytes) => .Ok(String.from_bytes(bytes)),
+        .Err(e) => .Err(e)
+      )
+    })
+  )
+);
+
+export BufReader;

package/std/sys/bufio/buf_writer.yo

@@ -0,0 +1,168 @@
+// std/sys/bufio/buf_writer.yo - Buffered writer for file descriptors
+//
+// Wraps a file descriptor with an internal buffer for efficient writes.
+// Reduces the number of system calls by batching small writes together.
+//
+// Example:
+//   { BufWriter } :: import "std/sys/bufio/buf_writer";
+//
+//   writer := BufWriter.new(fd);
+//   io.await(writer.write_string(String.from("hello\n"), using(io)));
+//   io.await(writer.flush(using(io)));
+
+{ ArrayList } :: import "../../collections/array_list";
+open import "../../string";
+{ IOError } :: import "../errors";
+IO_file :: import "../file";
+{ GlobalAllocator } :: import "../../allocator";
+{ malloc, free } :: GlobalAllocator;
+
+_DEFAULT_BUF_SIZE :: usize(4096);
+
+BufWriter :: object(
+  _fd       : i32,
+  _buf      : ArrayList(u8),
+  _offset   : u64,
+  _capacity : usize
+);
+
+impl(BufWriter,
+  // Create a buffered writer with default buffer size (4096 bytes).
+  new : (fn(fd: i32) -> Self)(
+    Self(
+      _fd: fd,
+      _buf: ArrayList(u8).with_capacity(_DEFAULT_BUF_SIZE),
+      _offset: u64(0),
+      _capacity: _DEFAULT_BUF_SIZE
+    )
+  ),
+
+  // Create a buffered writer with a custom buffer size.
+  with_capacity : (fn(fd: i32, capacity: usize) -> Self)(
+    Self(
+      _fd: fd,
+      _buf: ArrayList(u8).with_capacity(capacity),
+      _offset: u64(0),
+      _capacity: capacity
+    )
+  ),
+
+  // Return the underlying file descriptor.
+  fd : (fn(self: Self) -> i32)(
+    self._fd
+  ),
+
+  // Return the number of bytes currently buffered.
+  buffered : (fn(self: Self) -> usize)(
+    self._buf.len()
+  ),
+
+  // Internal: flush the buffer contents to fd.
+  _flush_inner : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))({
+    the_fd := self._fd;
+    io.async((using(io : IO)) => {
+      (write_err : Option(IOError)) = .None;
+
+      cond(
+        (self._buf.len() > usize(0)) => {
+          written := usize(0);
+          total := self._buf.len();
+
+          while runtime(((written < total) && write_err.is_none())), {
+            remaining := u32((total - written));
+            buf_ptr := self._buf.ptr().unwrap();
+            n := io.await(IO_file.write(the_fd, (buf_ptr &+ written), remaining, self._offset));
+            cond(
+              (n < i32(0)) => {
+                write_err = .Some(IOError.from_errno((i32(0) - n)));
+              },
+              true => {
+                written = (written + usize(n));
+                self._offset = (self._offset + u64(n));
+              }
+            );
+          };
+
+          self._buf = ArrayList(u8).with_capacity(self._capacity);
+        },
+        true => ()
+      );
+
+      match(write_err,
+        .Some(e) => .Err(e),
+        .None => .Ok(())
+      )
+    })
+  }),
+
+  // Write bytes from a pointer into the buffer.
+  // Automatically flushes when the buffer is full.
+  // Returns total number of bytes written.
+  write : (fn(self: Self, data: *(u8), size: u32, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))({
+    the_fd := self._fd;
+    io.async((using(io : IO)) => {
+      remaining := usize(size);
+      src_pos := usize(0);
+      (write_err : Option(IOError)) = .None;
+
+      while runtime(((remaining > usize(0)) && write_err.is_none())), {
+        space := (self._capacity - self._buf.len());
+        cond(
+          (space == usize(0)) => {
+            // Buffer full, flush it
+            flush_result := io.await(self._flush_inner(using(io)));
+            match(flush_result,
+              .Err(e) => { write_err = .Some(e); },
+              .Ok(_) => ()
+            );
+          },
+          true => {
+            to_copy := cond(
+              (remaining < space) => remaining,
+              true => space
+            );
+            i := usize(0);
+            while runtime((i < to_copy)), {
+              self._buf.push((data &+ (src_pos + i)).*);
+              i = (i + usize(1));
+            };
+            src_pos = (src_pos + to_copy);
+            remaining = (remaining - to_copy);
+          }
+        );
+      };
+
+      match(write_err,
+        .Some(e) => .Err(e),
+        .None => .Ok(i32(size))
+      )
+    })
+  }),
+
+  // Write a String to the buffer.
+  write_string : (fn(self: Self, s: String, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))(
+    io.async((using(io : IO)) => {
+      bytes := s.as_bytes();
+      result := io.await(self.write(bytes.ptr().unwrap(), u32(bytes.len()), using(io)));
+      result
+    })
+  ),
+
+  // Write bytes from an ArrayList to the buffer.
+  write_bytes : (fn(self: Self, data: ArrayList(u8), using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))(
+    io.async((using(io : IO)) => {
+      result := io.await(self.write(data.ptr().unwrap(), u32(data.len()), using(io)));
+      result
+    })
+  ),
+
+  // Flush all buffered data to the underlying file descriptor.
+  flush : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))(
+    io.async((using(io : IO)) => {
+      flush_result := io.await(self._flush_inner(using(io)));
+      flush_result
+    })
+  )
+);
+
+export BufWriter;

package/std/{io → sys}/clock.yo

@@ -1,4 +1,4 @@
-// std/io/clock.yo - High-resolution clock queries
+// std/sys/clock.yo - High-resolution clock queries
 //
 // Provides a synchronous wrapper for reading wall-clock and monotonic time.
 // Returns 0 on success, -errno / negative platform error on failure.

package/std/{io → sys}/constants.yo

@@ -1,4 +1,4 @@
-// std/io/constants.yo - File system constants
+// std/sys/constants.yo - File system constants
 //
 // File mode bits, permission bits, AT_* flags, open flags,
 // access mode constants, copyfile flags, directory entry types,

package/std/{io → sys}/copy.yo

@@ -1,4 +1,4 @@
-// std/io/copy.yo - File copy operations
+// std/sys/copy.yo - File copy operations
 //
 // Synchronous wrappers for copyfile/sendfile.
 // These are inherently synchronous on all platforms.

package/std/{io → sys}/dir.yo

@@ -1,4 +1,4 @@
-// std/io/dir.yo - Directory operations
+// std/sys/dir.yo - Directory operations
 //
 // Provides low-level directory manipulation wrappers around C runtime externs.
 //
@@ -12,8 +12,8 @@
 //   - Negative value: -errno on failure
 //
 // Example:
-//   { AT_FDCWD } :: import "std/io/constants";
-//   { mkdir, unlink, rename } :: import "std/io/dir";
+//   { AT_FDCWD } :: import "std/sys/constants";
+//   { mkdir, unlink, rename } :: import "std/sys/dir";
 //
 //   task := async {
 //     result := await mkdir(AT_FDCWD, *(u8)("/tmp/yo_test_dir"), i32(0o755));
@@ -83,9 +83,9 @@ readlink :: (fn(dirfd: i32, path: *(u8), buf: *(u8), bufsize: usize) -> i32)(
 // Iterate entries using dirent_reclen to advance through the buffer.
 //
 // Usage pattern:
-//   { openat, close } :: import "std/io/file";
-//   { AT_FDCWD, O_RDONLY, O_DIRECTORY } :: import "std/io/constants";
-//   { getdents, dirent_name, dirent_type } :: import "std/io/dir";
+//   { openat, close } :: import "std/sys/file";
+//   { AT_FDCWD, O_RDONLY, O_DIRECTORY } :: import "std/sys/constants";
+//   { getdents, dirent_name, dirent_type } :: import "std/sys/dir";
 //
 //   async {
 //     fd := await openat(AT_FDCWD, *(u8)("/tmp"), (O_RDONLY | O_DIRECTORY), i32(0));

package/std/{io → sys}/dns.yo

@@ -1,4 +1,4 @@
-// std/io/dns.yo - DNS resolution operations
+// std/sys/dns.yo - DNS resolution operations
 //
 // Provides async DNS resolution wrapping getaddrinfo/getnameinfo, plus
 // accessors for iterating the linked list of addrinfo results.
@@ -10,8 +10,8 @@
 // Example:
 //   { GlobalAllocator } :: import "../allocator";
 //   { malloc, free } :: GlobalAllocator;
-//   dns :: import "std/io/dns";
-//   { AF_INET } :: import "std/io/socket";
+//   dns :: import "std/sys/dns";
+//   { AF_INET } :: import "std/sys/socket";
 //
 //   async {
 //     result_ptr := dns.alloc_result();

package/std/{io → sys}/errors.yo

@@ -1,4 +1,4 @@
-// std/io/errors.yo - IOError type
+// std/sys/errors.yo - IOError type
 //
 // Comprehensive I/O error type with errno-to-error mapping.
 

package/std/{io → sys}/events.yo

@@ -1,4 +1,4 @@
-// std/io/events.yo - TTY, Poll, and FS Event constants
+// std/sys/events.yo - TTY, Poll, and FS Event constants
 
 {
   __yo_fs_event_init, __yo_fs_event_start,

package/std/{io → sys}/externs.yo

@@ -1,4 +1,4 @@
-// std/io/externs.yo - Extern C runtime function declarations
+// std/sys/externs.yo - Extern C runtime function declarations
 //
 // All low-level extern functions for async I/O operations.
 

package/std/{io → sys}/fallocate.yo

@@ -1,4 +1,4 @@
-// std/io/fallocate.yo - File space pre-allocation
+// std/sys/fallocate.yo - File space pre-allocation
 //
 // Synchronous wrapper for fallocate-style allocation.
 // Returns 0 on success, -errno on failure.

package/std/{io → sys}/fcntl.yo

@@ -1,4 +1,4 @@
-// std/io/fcntl.yo - File descriptor control operations
+// std/sys/fcntl.yo - File descriptor control operations
 //
 // Synchronous wrappers for file descriptor flags and close-on-exec flags.
 // Returns:

package/std/{io → sys}/file.yo

@@ -1,4 +1,4 @@
-// std/io/file.yo - Async and sync file operations
+// std/sys/file.yo - Async and sync file operations
 //
 // Provides low-level file I/O wrappers around the C runtime externs.
 //

package/std/{io → sys}/future.yo

@@ -1,4 +1,4 @@
-// std/io/future.yo - IOFuture type
+// std/sys/future.yo - IOFuture type
 //
 // Opaque handle to C async I/O future struct.
 

package/std/{io → sys}/iov.yo

@@ -1,4 +1,4 @@
-// std/io/iov.yo - Scatter/gather I/O
+// std/sys/iov.yo - Scatter/gather I/O
 //
 // Synchronous wrappers for vectored file descriptor I/O.
 // Returns byte count on success, -errno / negative platform error on failure.

package/std/{io → sys}/lock.yo

@@ -1,4 +1,4 @@
-// std/io/lock.yo - Advisory file locking
+// std/sys/lock.yo - Advisory file locking
 //
 // Synchronous wrapper for POSIX flock().
 // Returns 0 on success, -errno on failure.

package/std/{io → sys}/mmap.yo

@@ -1,4 +1,4 @@
-// std/io/mmap.yo - Memory-mapped I/O operations
+// std/sys/mmap.yo - Memory-mapped I/O operations
 //
 // Synchronous wrappers for mmap/munmap/mprotect/msync.
 //

package/std/{io → sys}/path.yo

@@ -1,4 +1,4 @@
-// std/io/path.yo - Path resolution
+// std/sys/path.yo - Path resolution
 //
 // Synchronous wrapper for realpath.
 // This is inherently synchronous on all platforms.

package/std/{io → sys}/perm.yo

@@ -1,4 +1,4 @@
-// std/io/perm.yo - File permission and access operations
+// std/sys/perm.yo - File permission and access operations
 //
 // Provides synchronous wrappers for chmod, chown, and access operations.
 // All operations return i32 directly (no IOFuture overhead).
@@ -8,8 +8,8 @@
 //   - Negative value: -errno on failure
 //
 // Example:
-//   perm :: import "std/io/perm";
-//   { AT_FDCWD, S_IRUSR, S_IWUSR, S_IRGRP, S_IROTH, F_OK, R_OK, W_OK } :: import "std/io/constants";
+//   perm :: import "std/sys/perm";
+//   { AT_FDCWD, S_IRUSR, S_IWUSR, S_IRGRP, S_IROTH, F_OK, R_OK, W_OK } :: import "std/sys/constants";
 //
 //   // Check if file exists and is readable
 //   ret := perm.access(AT_FDCWD, *(u8)("/tmp/test.txt"), (R_OK | W_OK));

package/std/{io → sys}/pipe.yo

@@ -1,4 +1,4 @@
-// std/io/pipe.yo - Pipe and file descriptor duplication operations
+// std/sys/pipe.yo - Pipe and file descriptor duplication operations
 //
 // Synchronous wrappers for pipe/dup/dup2.
 // These are inherently synchronous kernel operations on all platforms.

package/std/{io → sys}/process.yo

@@ -1,4 +1,4 @@
-// std/io/process.yo - Child process management
+// std/sys/process.yo - Child process management
 //
 // Provides cross-platform child process spawning, waiting, and signal delivery.
 // All async operations return IOFuture which resolves to:

package/std/{io → sys}/seek.yo

@@ -1,4 +1,4 @@
-// std/io/seek.yo - File position control
+// std/sys/seek.yo - File position control
 //
 // Synchronous wrapper for lseek.
 // Returns resulting absolute file offset on success, -errno on failure.

package/std/{io → sys}/signal.yo

@@ -1,4 +1,4 @@
-// std/io/signal.yo - Signal handling functions
+// std/sys/signal.yo - Signal handling functions
 //
 // Provides low-level wrappers for signal registration and delivery.
 

package/std/{io → sys}/signals.yo

@@ -1,4 +1,4 @@
-// std/io/signals.yo - POSIX signal constants
+// std/sys/signals.yo - POSIX signal constants
 //
 // Platform-aware signal numbers.
 // Uses process.platform for values that differ between Linux and macOS.

package/std/{io → sys}/socket.yo

@@ -1,4 +1,4 @@
-// std/io/socket.yo - Socket constants
+// std/sys/socket.yo - Socket constants
 //
 // Platform-aware socket constants for TCP, UDP, and Unix domain sockets.
 // Uses process.platform for values that differ between Linux and macOS.