updates to the process and window library, added more tests

Author: wakaztahir

lang/libs/process/posix/posix.ch

@@ -85,6 +85,7 @@ public func posix_execute(cfg : *ProcessConfig, out : *mut ProcessResult) : bool
 public func posix_spawn(cfg : *ProcessConfig, child : *mut ChildProcess) : bool {
     unsafe var stdout_pipe : [2]int;
     unsafe var stderr_pipe : [2]int;
+    unsafe var stdin_pipe : [2]int;
 
     if(cfg.capture_stdout) {
         if(pipe(&raw mut stdout_pipe[0]) != 0) { return false } else {}
@@ -95,29 +96,39 @@ public func posix_spawn(cfg : *ProcessConfig, child : *mut ChildProcess) : bool
             return false
         } else {}
     } else {}
+    // Always create a stdin pipe so write_stdin/close_stdin work.
+    if(pipe(&raw mut stdin_pipe[0]) != 0) {
+        if(cfg.capture_stdout) { close(stdout_pipe[0]); close(stdout_pipe[1]); } else {}
+        if(cfg.capture_stderr) { close(stderr_pipe[0]); close(stderr_pipe[1]); } else {}
+        return false
+    } else {}
 
     var pid = fork();
     if(pid == -1) {
         if(cfg.capture_stdout) { close(stdout_pipe[0]); close(stdout_pipe[1]); } else {}
         if(cfg.capture_stderr) { close(stderr_pipe[0]); close(stderr_pipe[1]); } else {}
+        close(stdin_pipe[0]); close(stdin_pipe[1]);
         return false
     } else {}
 
     if(pid == 0) {
         if(cfg.capture_stdout) { close(stdout_pipe[0]); dup2(stdout_pipe[1], 1); close(stdout_pipe[1]); } else {}
         if(cfg.capture_stderr) { close(stderr_pipe[0]); dup2(stderr_pipe[1], 2); close(stderr_pipe[1]); } else {}
+        // Child reads from stdin_pipe[0]; parent writes to stdin_pipe[1].
+        close(stdin_pipe[1]); dup2(stdin_pipe[0], 0); close(stdin_pipe[0]);
         var argv = build_argv(&raw mut cfg.args);
         execvp(argv.ptrs[0], &raw argv.ptrs[0]);
         _exit(1);
     } else {}
 
     if(cfg.capture_stdout) { close(stdout_pipe[1]); } else {}
     if(cfg.capture_stderr) { close(stderr_pipe[1]); } else {}
+    close(stdin_pipe[0]); // parent writes to stdin_pipe[1]
 
     child._unix.pid = pid;
     child._unix.stdout_fd = if(cfg.capture_stdout) stdout_pipe[0] else -1;
     child._unix.stderr_fd = if(cfg.capture_stderr) stderr_pipe[0] else -1;
-    child._unix.stdin_fd = -1;
+    child._unix.stdin_fd = stdin_pipe[1];
     child.is_running = true;
     return true
 }
@@ -142,6 +153,11 @@ public func posix_wait(child : *mut ChildProcess, out : *mut ProcessResult) : bo
         close(child._unix.stderr_fd);
         child._unix.stderr_fd = -1;
     } else {}
+    // Close stdin pipe if still open.
+    if(child._unix.stdin_fd >= 0) {
+        close(child._unix.stdin_fd);
+        child._unix.stdin_fd = -1;
+    } else {}
 
     var status : int = 0;
     waitpid(child._unix.pid, &raw mut status, 0);
@@ -207,6 +223,8 @@ func read_all_fd(fd : int, data : *mut vector<u8>) : bool {
 @extern public func close(fd : int) : int
 @extern public func read(fd : int, buf : *mut void, count : size_t) : isize
 @extern public func write(fd : int, buf : *void, count : size_t) : isize
+@extern public func getpid() : int
+@extern public func usleep(usec : int) : int
 
 const _WIFEXITED_MASK = 0x7f;
 func WIFEXITED(status : int) : bool { return (status & _WIFEXITED_MASK) == 0; }

lang/libs/process/src/process.ch

@@ -23,6 +23,26 @@ public struct ProcessResult {
     var output : ProcessOutput;
     var status : ExitStatus;
     var success : bool;
+
+    /// Get stdout as a string view (assumes UTF-8).
+    public func stdout_str(&self) : string_view {
+        return string_view(self.output.stdout_data.data() as *char, self.output.stdout_data.size())
+    }
+
+    /// Get stderr as a string view (assumes UTF-8).
+    public func stderr_str(&self) : string_view {
+        return string_view(self.output.stderr_data.data() as *char, self.output.stderr_data.size())
+    }
+
+    /// Get the exit code.
+    public func exit_code(&self) : int {
+        return self.status.code
+    }
+
+    /// Check whether the process exited successfully.
+    public func is_success(&self) : bool {
+        return self.success
+    }
 }
 
 public struct ProcessConfig {
@@ -165,7 +185,7 @@ public func kill(child : *mut ChildProcess, signal : int) : UT_Result {
         var r = TerminateProcess(child.win.h_process, 1u32);
         if(r == 0) {
             var e = ProcessError.OperationFailed(string("TerminateProcess failed"))
-            std::replace(&mut ret, Result.Err<UnitTy, ProcessError>(std::replace(&mut e, ProcessError.NotRunning())))
+            std::replace(&mut ret, Result.Err<UnitTy, ProcessError>(std::replace<ProcessError>(&mut e, ProcessError.NotRunning())))
             return std::replace<UT_Result>(&mut ret, zeroed:unsafe<UT_Result>())
         } else {}
         child.is_running = false;
@@ -178,4 +198,147 @@ public func kill(child : *mut ChildProcess, signal : int) : UT_Result {
     }
 }
 
+// ---------------------------------------------------------------------------
+// Process status & I/O
+// ---------------------------------------------------------------------------
+
+/// Non-blocking check whether a child process is still running.
+public func is_running(child : *mut ChildProcess) : bool {
+    if(!child.is_running) {
+        return false
+    }
+    comptime if(def.windows) {
+        // WaitForSingleObject with 0 timeout = non-blocking poll.
+        var rc = WaitForSingleObject(child.win.h_process, 0u32)
+        if(rc == 0u32) {
+            // Process has exited.
+            child.is_running = false
+            return false
+        }
+        return true
+    } else {
+        var status : int = 0
+        var ret = waitpid(child._unix.pid, &raw mut status, 1) // WNOHANG = 1
+        if(ret == 0) {
+            return true // still running
+        }
+        child.is_running = false
+        return false
+    }
+}
+
+/// Write data to the child process's stdin pipe.
+/// Returns Err if the child has no stdin pipe or the write fails.
+public func write_stdin(child : *mut ChildProcess, data : *vector<u8>) : UT_Result {
+    var ret = zeroed:unsafe<UT_Result>()
+    comptime if(def.windows) {
+        var e = ProcessError.OperationFailed(string("write_stdin not implemented on Windows"))
+        std::replace(&mut ret, Result.Err<UnitTy, ProcessError>(std::replace<ProcessError>(&mut e, ProcessError.NotRunning())))
+        return std::replace<UT_Result>(&mut ret, zeroed:unsafe<UT_Result>())
+    } else {
+        if(child._unix.stdin_fd < 0) {
+            var e = ProcessError.InvalidArgs(string("no stdin pipe"))
+            std::replace(&mut ret, Result.Err<UnitTy, ProcessError>(std::replace<ProcessError>(&mut e, ProcessError.NotRunning())))
+            return std::replace<UT_Result>(&mut ret, zeroed:unsafe<UT_Result>())
+        }
+        if(data.size() > 0) {
+            var written = write(child._unix.stdin_fd, data.data() as *void, data.size())
+            if(written < 0) {
+                var e = ProcessError.IoError(string("write to stdin failed"))
+                std::replace(&mut ret, Result.Err<UnitTy, ProcessError>(std::replace<ProcessError>(&mut e, ProcessError.NotRunning())))
+                return std::replace<UT_Result>(&mut ret, zeroed:unsafe<UT_Result>())
+            }
+        }
+        std::replace(&mut ret, Result.Ok<UnitTy, ProcessError>(UnitTy{}))
+        return std::replace<UT_Result>(&mut ret, zeroed:unsafe<UT_Result>())
+    }
+}
+
+/// Close the stdin pipe of a child process (sends EOF to the child).
+public func close_stdin(child : *mut ChildProcess) : UT_Result {
+    var ret = zeroed:unsafe<UT_Result>()
+    comptime if(def.windows) {
+        var e = ProcessError.OperationFailed(string("close_stdin not implemented on Windows"))
+        std::replace(&mut ret, Result.Err<UnitTy, ProcessError>(std::replace<ProcessError>(&mut e, ProcessError.NotRunning())))
+        return std::replace<UT_Result>(&mut ret, zeroed:unsafe<UT_Result>())
+    } else {
+        if(child._unix.stdin_fd >= 0) {
+            close(child._unix.stdin_fd)
+            child._unix.stdin_fd = -1
+        }
+        std::replace(&mut ret, Result.Ok<UnitTy, ProcessError>(UnitTy{}))
+        return std::replace<UT_Result>(&mut ret, zeroed:unsafe<UT_Result>())
+    }
+}
+
+/// Reap the child process and return its exit status without blocking.
+/// If the process is still running, returns NotRunning error.
+public func try_wait(child : *mut ChildProcess) : PR_Result {
+    var ret = zeroed:unsafe<PR_Result>()
+    if(!child.is_running) {
+        var e = ProcessError.NotRunning()
+        pr_err(e, &mut ret)
+        return std::replace<PR_Result>(&mut ret, zeroed:unsafe<PR_Result>())
+    }
+    comptime if(def.windows) {
+        var e = ProcessError.OperationFailed(string("try_wait not implemented on Windows"))
+        pr_err(e, &mut ret)
+        return std::replace<PR_Result>(&mut ret, zeroed:unsafe<PR_Result>())
+    } else {
+        var status : int = 0
+        var pid = waitpid(child._unix.pid, &raw mut status, 1) // WNOHANG
+        if(pid == 0) {
+            var e = ProcessError.NotRunning()
+            pr_err(e, &mut ret)
+            return std::replace<PR_Result>(&mut ret, zeroed:unsafe<PR_Result>())
+        }
+        var result = zeroed:unsafe<ProcessResult>()
+        var exit_code : int = 0
+        var signaled : bool = false
+        var signal_no : int = 0
+        if(WIFEXITED(status)) { exit_code = WEXITSTATUS(status) }
+        else if(WIFSIGNALED(status)) { signaled = true; signal_no = WTERMSIG(status); exit_code = -1 }
+        child.is_running = false
+        result.status.code = exit_code
+        result.status.signaled = signaled
+        result.status.signal = signal_no
+        result.success = (exit_code == 0 && !signaled)
+        pr_ok(&mut result, &mut ret)
+        return std::replace<PR_Result>(&mut ret, zeroed:unsafe<PR_Result>())
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Process-wide utilities
+// ---------------------------------------------------------------------------
+
+/// Get the current process ID.
+public func current_pid() : int {
+    comptime if(def.windows) {
+        return GetCurrentProcessId() as int
+    } else {
+        return getpid()
+    }
+}
+
+/// Sleep for the given number of milliseconds.
+public func sleep_ms(ms : int) {
+    comptime if(def.windows) {
+        Sleep(ms as u32)
+    } else {
+        usleep(ms * 1000)
+    }
+}
+
+/// Get the PID of a child process.
+public func child_pid(child : *mut ChildProcess) : int {
+    comptime if(def.windows) {
+        // Windows doesn't expose a PID from the HANDLE in a portable way;
+        // return 0 as a sentinel.
+        return 0
+    } else {
+        return child._unix.pid
+    }
+}
+
 } // end namespace process

lang/libs/process/src/types.ch

@@ -8,6 +8,7 @@ public variant ProcessError {
     OperationFailed(msg : string)
     NotRunning()
     TimedOut()
+    IoError(msg : string)
 
     func message(&self) : string {
         switch(self) {
@@ -23,6 +24,11 @@ public variant ProcessError {
             }
             NotRunning() => return string("ProcessError: process is not running")
             TimedOut() => return string("ProcessError: operation timed out")
+            IoError(msg) => {
+                var s = string("ProcessError: I/O error: ")
+                s.append_view(msg.to_view())
+                return s
+            }
         }
     }
 }

lang/libs/process/win/win.ch

@@ -17,4 +17,19 @@ public namespace process {
 @stdcall
 public func TerminateProcess(hProcess : HANDLE, uExitCode : UINT) : BOOL;
 
+@dllimport
+@extern
+@stdcall
+public func WaitForSingleObject(hHandle : HANDLE, dwMilliseconds : DWORD) : DWORD;
+
+@dllimport
+@extern
+@stdcall
+public func GetCurrentProcessId() : DWORD;
+
+@dllimport
+@extern
+@stdcall
+public func Sleep(dwMilliseconds : DWORD) : void;
+
 } // end namespace process

lang/libs/window/posix/linux.ch

@@ -193,6 +193,7 @@ const GDK_ACTION_COPY = 2
 @extern public func gtk_widget_add_events(widget : *mut GtkWidget, events : int)
 
 @extern public func g_signal_connect_data(instance : *mut void, signal : *char, handler : *mut void, data : *mut void, destroy_data : *mut void, connect_flags : int) : u64
+@extern public func g_idle_add(function : *mut void, data : *mut void) : u32
 
 // GObject object-data — used for the stable per-widget callback context
 // (g_object_set_data_full auto-frees the context when the widget is destroyed)
@@ -1044,4 +1045,15 @@ public func window_quit() {
     }
 }
 
+func linux_empty_callback(data : *mut void) : int {
+    // Return 0 so GTK removes the idle source after firing once.
+    return 0
+}
+
+/// Post an empty event to wake up the message loop.
+/// Useful for waking up the message loop from another thread.
+public func window_post_empty_event() {
+    g_idle_add(linux_empty_callback as *mut void, null)
+}
+
 } // end namespace window

lang/libs/window/win/win.ch

@@ -297,6 +297,7 @@ func win_set_layered_alpha(hwnd : HWND, alpha : BYTE) {
 @extern @stdcall @dllimport public func GetSystemMetrics(nIndex : int) : int
 // NOTE: the SDK header maps LoadImage -> LoadImageW (the real user32 export).
 @extern @stdcall @dllimport public func LoadImageW(hInstance : HINSTANCE, name : LPCWSTR, type : UINT, cx : int, cy : int, fuLoad : UINT) : HANDLE
+@extern @stdcall @dllimport public func PostMessageA(hwnd : HWND, msg : UINT, wp : WPARAM, lp : LPARAM) : BOOL
 
 // shell32 (drag & drop)
 @extern @stdcall @dllimport public func DragAcceptFiles(hwnd : HWND, fAccept : BOOL) : void
@@ -1064,4 +1065,23 @@ public func window_quit() {
     PostQuitMessage(0)
 }
 
+/// Returns 1 if the last window_run() returned because a window was destroyed
+/// (the user closed it) rather than because window_quit() was called.
+/// On Windows this mirrors the Linux backend's g_quit_by_destroy flag.
+public func window_quit_by_destroy() : int {
+    // On Windows, WM_DESTROY always calls PostQuitMessage which exits the
+    // message loop, so the distinction between "user closed" and
+    // "window_quit()" is not tracked separately.  Return 0 for now — the
+    // webview library guards its destroy path with window_is_created() checks
+    // which is sufficient on this platform.
+    return 0
+}
+
+/// Post a empty message to the window's message queue.
+/// Useful for waking up the message loop from another thread.
+public func window_post_empty_event() {
+    // PostMessage with WM_NULL is the standard way to wake a message loop.
+    PostMessageA(null, 0u32, 0, 0)
+}
+
 } // end namespace window

lang/tests/process/chemical.mod

@@ -7,3 +7,4 @@ import test
 import test_env
 import process
 import environment
+import window