@shd101wyy/yo 0.1.21 → 0.1.22

package/std/process/command.yo

@@ -0,0 +1,303 @@
+//! High-level child-process spawning with builder-style configuration.
+//!
+//! Wraps `std/sys/process` with a fluent API for constructing argv, capturing
+//! stdout/stderr through pipes, and waiting for the child to exit.
+//!
+//! # Example
+//!
+//! ```rust
+//! { Command } :: import "std/process/command";
+//! { Exception, AnyError } :: import "std/error";
+//!
+//! main :: (fn(using(io : IO)) -> unit)({
+//!   given(exn) := Exception(
+//!     throw : (fn(forall(T : Type), error: AnyError) -> T)(
+//!       { println(error); panic("Exception"); }
+//!     )
+//!   );
+//!
+//!   cmd := Command.new(`echo`);
+//!   cmd.arg(`hello`);
+//!   cmd.arg(`world`);
+//!   out := io.await(cmd.output());
+//!   assert(out.status.success(), "echo should succeed");
+//! });
+//! ```
+
+open import "../collections/array_list";
+open import "../string";
+{ Exception } :: import "../error";
+{ IOError } :: import "../sys/errors";
+IO_process :: import "../sys/process";
+IO_file :: import "../sys/file";
+IO_pipe :: import "../sys/pipe";
+{ GlobalAllocator } :: import "../allocator";
+{ malloc, free } :: GlobalAllocator;
+
+// ============================================================================
+// ExitStatus
+// ============================================================================
+
+/// The result of a finished child process.
+///
+/// Holds the raw waitpid status code along with helpers to extract the exit
+/// code and termination signal.
+ExitStatus :: struct(
+  /// Encoded waitpid status. Use `code()` / `signal()` helpers instead of
+  /// reading this directly when possible.
+  raw : i32
+);
+
+impl(ExitStatus,
+  /// Returns the process exit code (0..255 on Unix). Returns 0 when the
+  /// process was terminated by a signal.
+  code : (fn(self: Self) -> i32)(
+    IO_process.exit_status(self.raw)
+  ),
+
+  /// Returns the signal number that terminated the process, or 0 if the
+  /// process exited normally.
+  signal : (fn(self: Self) -> i32)(
+    IO_process.term_signal(self.raw)
+  ),
+
+  /// Returns true if the child exited with status code 0.
+  success : (fn(self: Self) -> bool)(
+    ((IO_process.exit_status(self.raw) == i32(0)) && (IO_process.term_signal(self.raw) == i32(0)))
+  )
+);
+
+// ============================================================================
+// Output
+// ============================================================================
+
+/// Captured output of a child process.
+///
+/// Returned by `Command.output`. Holds the exit status plus the bytes captured
+/// from the child's stdout and stderr.
+Output :: object(
+  status : ExitStatus,
+  stdout : ArrayList(u8),
+  stderr : ArrayList(u8)
+);
+
+// ============================================================================
+// Command
+// ============================================================================
+
+/// Builder for a child-process invocation.
+///
+/// Construct with `Command.new(program)`, then chain mutating builder methods
+/// (`arg`, `args`, `env_clear`) before invoking `status()` or `output()`.
+Command :: object(
+  _program : String,
+  _args    : ArrayList(String),
+  _stdin_fd  : i32,
+  _stdout_fd : i32,
+  _stderr_fd : i32
+);
+
+impl(Command,
+  /// Create a new `Command` invoking `program`. The program name is also used
+  /// as `argv[0]` unless a different first arg is pushed manually before
+  /// invocation.
+  new : (fn(program: String) -> Self)(
+    Self(
+      _program: program,
+      _args: ArrayList(String).new(),
+      _stdin_fd: i32(-1),
+      _stdout_fd: i32(-1),
+      _stderr_fd: i32(-1)
+    )
+  ),
+
+  /// Append a single argument to the argv list.
+  arg : (fn(self: *(Self), a: String) -> unit)({
+    self._args.push(a);
+    ()
+  }),
+
+  /// Append multiple arguments to the argv list.
+  args : (fn(self: *(Self), more: ArrayList(String)) -> unit)({
+    n := more.len();
+    i := usize(0);
+    while runtime((i < n)), {
+      match(more.get(i),
+        .Some(s) => { self._args.push(s); },
+        .None => ()
+      );
+      i = (i + usize(1));
+    };
+  })
+);
+
+// ============================================================================
+// Internal helpers
+// ============================================================================
+
+// Convert each entry of `(program + args)` into an owned NUL-terminated
+// `ArrayList(u8)`. The returned list owns the C-string storage; callers
+// extract the raw `*(u8)` pointers separately.
+_build_cstr_storage :: (fn(self: *(Command)) -> ArrayList(ArrayList(u8)))({
+  storage := ArrayList(ArrayList(u8)).new();
+  storage.push(self._program.to_cstr());
+  n := self._args.len();
+  i := usize(0);
+  while runtime((i < n)), {
+    match(self._args.get(i),
+      .Some(s) => { storage.push(s.to_cstr()); },
+      .None => ()
+    );
+    i = (i + usize(1));
+  };
+  return storage;
+});
+
+// Spawn the child with the given inherited/redirected fds and return the pid.
+// Builds argv as a fixed `?*(u8)` array on the heap. Caller is responsible for
+// freeing `argv_buf` AND keeping `storage` alive until after `__yo_async_spawn_start`
+// returns the pid (since the kernel reads argv synchronously inside the syscall).
+_spawn_with_fds :: (fn(
+  self: *(Command),
+  stdin_fd: i32,
+  stdout_fd: i32,
+  stderr_fd: i32,
+  using(io : IO, exn : Exception)
+) -> Impl(Future(i32, IO, Exception)))({
+  io.async((using(io, exn)) => {
+    storage := _build_cstr_storage(self);
+    argc := storage.len();
+
+    // Allocate argv buffer: argc entries + 1 null terminator.
+    argv_bytes := (sizeof(?*(u8)) * (argc + usize(1)));
+    argv_raw := malloc(argv_bytes).unwrap();
+    argv_buf := *(?*(u8))(argv_raw);
+
+    // Fill argv pointers from each owning ArrayList(u8) in storage.
+    j := usize(0);
+    while runtime((j < argc)), {
+      match(storage.get(j),
+        .Some(cs) => match(cs.ptr(),
+          .Some(p) => { (argv_buf &+ j).* = .Some(p); },
+          .None => { (argv_buf &+ j).* = .None; }
+        ),
+        .None => { (argv_buf &+ j).* = .None; }
+      );
+      j = (j + usize(1));
+    };
+    (argv_buf &+ argc).* = .None;
+
+    // Resolve program path C string (always present — _build_cstr_storage pushes program first).
+    program_cstr := (argv_buf &+ usize(0)).*.unwrap();
+
+    pid := io.await(IO_process.spawn(program_cstr, argv_buf, .None, stdin_fd, stdout_fd, stderr_fd));
+
+    // Free argv buffer (storage is dropped naturally at scope end).
+    free(.Some(argv_raw));
+
+    IOError.check(pid)
+  })
+});
+
+// Read all available bytes from `fd` into a freshly returned ArrayList(u8)
+// until EOF (read returns 0).
+_drain_fd :: (fn(fd: i32, using(io : IO, exn : Exception)) -> Impl(Future(ArrayList(u8), IO, Exception)))({
+  io.async((using(io, exn)) => {
+    buf_size := usize(4096);
+    buf := *(u8)(malloc(buf_size).unwrap());
+    out := ArrayList(u8).new();
+    while runtime(true), {
+      n := io.await(IO_file.read(fd, buf, u32(buf_size), u64(0)));
+      cond(
+        (n < i32(0)) => {
+          free(.Some(*(void)(buf)));
+          exn.throw(dyn IOError.from_errno((i32(0) - n)));
+        },
+        (n == i32(0)) => break,
+        true => {
+          k := usize(0);
+          while runtime((k < usize(n))), {
+            out.push((buf &+ k).*);
+            k = (k + usize(1));
+          };
+        }
+      );
+    };
+    free(.Some(*(void)(buf)));
+    out
+  })
+});
+
+// ============================================================================
+// Public Command methods (status / output)
+// ============================================================================
+
+impl(Command,
+  /// Spawn the child with stdio inherited from the parent, wait for it to
+  /// exit, and return its `ExitStatus`.
+  status : (fn(self: *(Self), using(io : IO)) -> Impl(Future(ExitStatus, IO, Exception)))({
+    io.async((using(io, exn)) => {
+      pid := io.await(_spawn_with_fds(self, i32(-1), i32(-1), i32(-1)));
+      raw := io.await(IO_process.waitpid(pid, i32(0)));
+      IOError.check(raw);
+      ExitStatus(raw: raw)
+    })
+  }),
+
+  /// Spawn the child with stdout and stderr captured through pipes. Waits for
+  /// the child to exit and returns the exit status plus the captured bytes.
+  output : (fn(self: *(Self), using(io : IO)) -> Impl(Future(Output, IO, Exception)))({
+    io.async((using(io, exn)) => {
+      // Create stdout and stderr pipes.
+      out_fd_buf := MaybeUninit(Array(i32, usize(2))).new();
+      out_fd := *(i32)(out_fd_buf.as_ptr());
+      pr1 := IO_pipe.pipe(out_fd);
+      cond(
+        (pr1 < i32(0)) => exn.throw(dyn IOError.from_errno((i32(0) - pr1))),
+        true => ()
+      );
+      out_read := (out_fd &+ usize(0)).*;
+      out_write := (out_fd &+ usize(1)).*;
+
+      err_fd_buf := MaybeUninit(Array(i32, usize(2))).new();
+      err_fd := *(i32)(err_fd_buf.as_ptr());
+      pr2 := IO_pipe.pipe(err_fd);
+      cond(
+        (pr2 < i32(0)) => {
+          io.await(IO_file.close(out_read));
+          io.await(IO_file.close(out_write));
+          exn.throw(dyn IOError.from_errno((i32(0) - pr2)));
+        },
+        true => ()
+      );
+      err_read := (err_fd &+ usize(0)).*;
+      err_write := (err_fd &+ usize(1)).*;
+
+      // Spawn child with the write ends of both pipes.
+      pid := io.await(_spawn_with_fds(self, i32(-1), out_write, err_write));
+
+      // Close write ends in parent so reads see EOF when child exits.
+      io.await(IO_file.close(out_write));
+      io.await(IO_file.close(err_write));
+
+      // Drain both pipes sequentially.
+      stdout_buf := io.await(_drain_fd(out_read));
+      stderr_buf := io.await(_drain_fd(err_read));
+
+      io.await(IO_file.close(out_read));
+      io.await(IO_file.close(err_read));
+
+      raw := io.await(IO_process.waitpid(pid, i32(0)));
+      IOError.check(raw);
+      Output(
+        status: ExitStatus(raw: raw),
+        stdout: stdout_buf,
+        stderr: stderr_buf
+      )
+    })
+  })
+);
+
+export
+  Command, ExitStatus, Output
+;

package/std/process/index.yo

@@ -0,0 +1,45 @@
+//! Process information: platform/arch detection, child-process spawning, and exit.
+//!
+//! Environment variables, command-line arguments, and current working
+//! directory live in `std/env`.
+
+/// Current target platform as a compile-time string.
+/// One of: "linux", "macos", "windows", "freebsd", "emscripten", "wasi".
+platform :: __yo_process_platform();
+export platform;
+
+/// Platform constants for compile-time platform comparisons.
+Platform :: {
+  Linux : "linux",
+  Macos : "macos",
+  Windows : "windows",
+  FreeBSD : "freebsd",
+  Emscripten : "emscripten",
+  Wasi : "wasi"
+};
+export Platform;
+
+/// Current target architecture as a compile-time string.
+/// One of: "x86_64", "aarch64", "x86", "arm", "wasm32".
+arch :: __yo_process_arch();
+export arch;
+
+/// Architecture constants for compile-time architecture comparisons.
+Arch :: {
+  X86_64 : "x86_64",
+  Aarch64 : "aarch64",
+  X86 : "x86",
+  Arm : "arm",
+  Wasm32 : "wasm32"
+};
+export Arch;
+
+/// Exit the process with the given status code.
+exit :: (fn(code : usize) -> unit) {
+  { exit : _exit } :: import "../libc/stdlib";
+  _exit(int(code));
+};
+export exit;
+
+_command :: import "./command.yo";
+export ...(_command);

package/std/string/index.yo

@@ -2,8 +2,10 @@
 
 _rune :: import "./rune.yo";
 _string :: import "./string.yo";
+_string_builder :: import "./string_builder.yo";
 
 export
   ...(_rune),
-  ...(_string)
+  ...(_string),
+  ...(_string_builder)
 ;

package/std/string/string.yo

@@ -1558,6 +1558,226 @@ impl(String,
   )
 );
 
+/// === String utility methods ===
+
+/**
+ * Line iterator for `String` — yields one line at a time (split on `\n`).
+ * The trailing newline is not included in each yielded line.
+ * Used by `lines()`.
+ */
+StringLines :: struct(
+  _string     : String,
+  _byte_index : usize
+);
+
+impl(StringLines, Iterator(
+  Item : String,
+  next : (fn(self : *(Self)) -> Option(String))(
+    match(self._string._bytes,
+      .None => .None,
+      .Some(al) => {
+        total := al.len();
+        cond(
+          (self._byte_index >= total) => .None,
+          true => {
+            start := self._byte_index;
+            i := start;
+            while ((i < total)),
+                  (i = (i + usize(1))),
+            {
+              byte_opt := al.get(i);
+              match(byte_opt,
+                .Some(b) => {
+                  cond(
+                    (b == u8(10)) => { break; },
+                    true => ()
+                  );
+                },
+                .None => ()
+              );
+            };
+            line_buf := ArrayList(u8).with_capacity((i - start));
+            j := start;
+            while ((j < i)),
+                  (j = (j + usize(1))),
+            {
+              byte_opt := al.get(j);
+              match(byte_opt,
+                .Some(b) => { line_buf.push(b); },
+                .None => ()
+              );
+            };
+            self._byte_index = cond(
+              (i < total) => (i + usize(1)),
+              true => total
+            );
+            cond(
+              (line_buf.len() == usize(0)) => .Some(String(_bytes: .None)),
+              true => .Some(String(_bytes: .Some(line_buf)))
+            )
+          }
+        )
+      }
+    )
+  )
+));
+
+impl(String,
+  /**
+   * Returns a line iterator over the string.
+   * Each call to `next()` yields the next line (without the trailing `\n`).
+   *
+   * ## Example
+   * ```rust
+   * s := `hello\nworld`;
+   * iter := s.lines();
+   * assert(iter.next() == .Some(`hello`), "first line");
+   * assert(iter.next() == .Some(`world`), "second line");
+   * assert(iter.next() == .None, "done");
+   * ```
+   */
+  lines : (fn(self : Self) -> StringLines)(
+    StringLines(_string: self, _byte_index: usize(0))
+  ),
+
+  /**
+   * Returns a new string containing `n` copies of `self`.
+   * Returns an empty string when `n == 0` or `self` is empty.
+   *
+   * ## Example
+   * ```rust
+   * assert(`ab`.repeat(usize(3)) == `ababab`, "repeat");
+   * assert(`x`.repeat(usize(0)) == ``, "repeat 0");
+   * ```
+   */
+  repeat : (fn(self: Self, n: usize) -> Self)({
+    cond(
+      (n == usize(0)) => Self(_bytes: .None),
+      self.is_empty() => Self(_bytes: .None),
+      true => {
+        self_byte_len := self.bytes_len();
+        total := (self_byte_len * n);
+        buf := ArrayList(u8).with_capacity(total);
+        i := usize(0);
+        while ((i < n)),
+              (i = (i + usize(1))),
+        {
+          match(self._bytes,
+            .Some(al) => {
+              j := usize(0);
+              while ((j < self_byte_len)),
+                    (j = (j + usize(1))),
+              {
+                byte_opt := al.get(j);
+                match(byte_opt,
+                  .Some(b) => { buf.push(b); },
+                  .None => ()
+                );
+              };
+            },
+            .None => ()
+          );
+        };
+        Self(_bytes: .Some(buf))
+      }
+    )
+  }),
+
+  /**
+   * Join an `ArrayList(String)` with this string as separator.
+   * Returns an empty string when `items` is empty.
+   *
+   * ## Example
+   * ```rust
+   * items := ArrayList(String).new();
+   * items.push(`a`);
+   * items.push(`b`);
+   * items.push(`c`);
+   * result := `, `.join(items);
+   * assert(result == `a, b, c`, "join");
+   * ```
+   */
+  join : (fn(self: Self, items: ArrayList(Self)) -> Self)({
+    count := items.len();
+    cond(
+      (count == usize(0)) => Self(_bytes: .None),
+      true => {
+        sep_byte_len := self.bytes_len();
+        total_bytes := usize(0);
+        k := usize(0);
+        while ((k < count)),
+              (k = (k + usize(1))),
+        {
+          item_opt := items.get(k);
+          match(item_opt,
+            .Some(item) => {
+              total_bytes = (total_bytes + item.bytes_len());
+            },
+            .None => ()
+          );
+        };
+        cond(
+          (count > usize(1)) => {
+            total_bytes = (total_bytes + (sep_byte_len * (count - usize(1))));
+          },
+          true => ()
+        );
+        buf := ArrayList(u8).with_capacity(total_bytes);
+        m := usize(0);
+        while ((m < count)),
+              (m = (m + usize(1))),
+        {
+          item_opt := items.get(m);
+          match(item_opt,
+            .Some(item) => {
+              match(item._bytes,
+                .Some(al) => {
+                  p := usize(0);
+                  while ((p < al.len())),
+                        (p = (p + usize(1))),
+                  {
+                    byte_opt := al.get(p);
+                    match(byte_opt,
+                      .Some(b) => { buf.push(b); },
+                      .None => ()
+                    );
+                  };
+                },
+                .None => ()
+              );
+              cond(
+                (m < (count - usize(1))) => {
+                  match(self._bytes,
+                    .Some(sep_al) => {
+                      q := usize(0);
+                      while ((q < sep_byte_len)),
+                            (q = (q + usize(1))),
+                      {
+                        byte_opt := sep_al.get(q);
+                        match(byte_opt,
+                          .Some(b) => { buf.push(b); },
+                          .None => ()
+                        );
+                      };
+                    },
+                    .None => ()
+                  );
+                },
+                true => ()
+              );
+            },
+            .None => ()
+          );
+        };
+        cond(
+          (buf.len() == usize(0)) => Self(_bytes: .None),
+          true => Self(_bytes: .Some(buf))
+        )
+      }
+    )
+  })
+);
+
 /// === Numeric parsing methods ===
 
 impl(String,
@@ -1932,9 +2152,33 @@ impl(String, Index(usize)(
   )
 ));
 
+/// Clone implementation — produces an independent byte-level copy.
+impl(String, Clone(
+  clone : (fn(self: *(Self)) -> Self)(
+    match(self._bytes,
+      .None => Self(_bytes: .None),
+      .Some(al) => {
+        n := al.len();
+        cond(
+          (n == usize(0)) => Self(_bytes: .None),
+          true => {
+            buf := ArrayList(u8).with_capacity(n);
+            match(al._ptr,
+              .Some(ptr) => buf.extend_from_ptr(ptr, n),
+              .None => ()
+            );
+            Self(_bytes: .Some(buf))
+          }
+        )
+      }
+    )
+  )
+));
+
 export
   String,
   StringError,
   StringChars,
-  StringBytes
+  StringBytes,
+  StringLines
 ;