@shd101wyy/yo 0.1.26 → 0.1.28

package/std/process/command.yo

@@ -23,21 +23,18 @@
 //!   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";
+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
@@ -47,30 +44,26 @@ ExitStatus :: struct(
   /// reading this directly when possible.
   raw : i32
 );
-
-impl(ExitStatus,
+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)(
+  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)(
+  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)))
+  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
@@ -80,185 +73,184 @@ Output :: object(
   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,
+  _args : ArrayList(String),
+  _stdin_fd : i32,
   _stdout_fd : i32,
   _stderr_fd : i32
 );
-
-impl(Command,
+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)(
+  new : (fn(program : String) -> Self)(
     Self(
-      _program: program,
-      _args: ArrayList(String).new(),
-      _stdin_fd: i32(-1),
-      _stdout_fd: i32(-1),
-      _stderr_fd: i32(-1)
+      _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)({
+  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)({
+  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); },
+    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)))({
+_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()); },
+  while(runtime(i < n), {
+    match(
+      self._args.get(i),
+      .Some(s) => {
+        storage.push(s.to_cstr());
+      },
       .None => ()
     );
     i = (i + usize(1));
-  };
-  return storage;
+  });
+  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)))(
+_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; }
+    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; }
+        .None => {
+          (argv_buf &+ j).* =.None;
+        }
       );
       j = (j + usize(1));
-    };
-    (argv_buf &+ argc).* = .None;
-
+    });
+    (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));
-
+    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)))(
+_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), {
+    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)));
+          exn.throw(dyn(IOError.from_errno(i32(0) - n)));
         },
         (n == i32(0)) => break,
         true => {
           k := usize(0);
-          while runtime((k < usize(n))), {
+          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,
+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)))(
+  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)));
+      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)
+      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)))(
+  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))),
+        (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);
@@ -266,38 +258,30 @@ impl(Command,
         (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)));
+          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));
-
+      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
+        status : ExitStatus(raw : raw),
+        stdout : stdout_buf,
+        stderr : stderr_buf
       )
     })
   )
 );
-
-export
-  Command, ExitStatus, Output
-;
+export(Command, ExitStatus, Output);

package/std/process/index.yo

@@ -2,44 +2,25 @@
 //!
 //! 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;
-
+export(platform);
 /// Platform constants for compile-time platform comparisons.
-Platform :: {
-  Linux : "linux",
-  Macos : "macos",
-  Windows : "windows",
-  FreeBSD : "freebsd",
-  Emscripten : "emscripten",
-  Wasi : "wasi"
-};
-export Platform;
-
+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;
-
+export(arch);
 /// Architecture constants for compile-time architecture comparisons.
-Arch :: {
-  X86_64 : "x86_64",
-  Aarch64 : "aarch64",
-  X86 : "x86",
-  Arm : "arm",
-  Wasm32 : "wasm32"
-};
-export Arch;
-
+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 :: (fn(code : usize) -> unit)({
+  { exit : _exit } :: import("../libc/stdlib");
   _exit(int(code));
-};
-export exit;
-
-_command :: import "./command.yo";
-export ...(_command);
+});
+export(exit);
+_command :: import("./command.yo");
+export(...(_command));