Simplify API

Author: lerno

lib/std/os/process.c3

@@ -41,38 +41,30 @@ constdef SpawnOptions
 	ASYNC_OUTPUT        = 1 << 2,
 	NO_WINDOW           = 1 << 3,
 	NO_PATH_SEARCH      = 1 << 4,
-	INHERIT_STDIO @deprecated = 1 << 5
+	INHERIT_STDIO       = 1 << 5
 }
 
-const INHERIT_STDIO_MASK @local = 1 << 5;
 
 alias RawFd = env::WIN32 ? Win32_HANDLE : CInt;
 
 enum ProcessStdioAction
 {
+	DEFAULT,
 	CAPTURE,
 	INHERIT,
 	BIND
 }
 
 struct ProcessStdio
 {
-	ProcessStdioAction kind;
+	ProcessStdioAction action;
 	RawFd fd;
 }
 
-const ProcessStdio CAPTURE = { .kind = CAPTURE };
-const ProcessStdio INHERIT = { .kind = INHERIT };
-macro ProcessStdio bind(RawFd fd) => { .kind = BIND, .fd = fd };
-
-struct ProcessStdioSet
-{
-	ProcessStdio stdin;
-	ProcessStdio stdout;
-	ProcessStdio stderr;
-}
-
-const ProcessStdioSet INHERIT_STDIO = { .stdin.kind = INHERIT, .stdout.kind = INHERIT, .stderr.kind = INHERIT };
+const ProcessStdio CAPTURE = { .action = CAPTURE };
+const ProcessStdio INHERIT = { .action = INHERIT };
+const ProcessStdio DEFAULT = { .action = DEFAULT };
+macro ProcessStdio bind(RawFd fd) => { .action = BIND, .fd = fd };
 
 fn String? run_capture_stdout(char[] buffer, String[] command_line, SpawnOptions options = {}, String[] environment = {})
 {
@@ -84,18 +76,24 @@ fn String? run_capture_stdout(char[] buffer, String[] command_line, SpawnOptions
 	return (String)buffer[:len - 1];
 }
 
-fn int? run(String[] command_line, SpawnOptions options = {}, String[] environment = {}, ProcessStdioSet stdio = {})
+fn int? run(String[] command_line, SpawnOptions options = {}, String[] environment = {},
+            ProcessStdio in = DEFAULT, ProcessStdio out = DEFAULT, ProcessStdio err = DEFAULT)
 {
-	Process process = process::spawn(command_line, options, environment, stdio)!;
+	Process process = process::spawn(command_line, options, environment, in, out, err)!;
 	defer (void)process.destroy();
 	return process.join()!;
 }
 
+
 <*
  @require !environment || !(options & INHERIT_ENV)
 *>
-fn Process? spawn(String[] command_line, SpawnOptions options = {}, String[] environment = {}, ProcessStdioSet stdio = {}) @if(env::WIN32)
+fn Process? spawn(String[] command_line, SpawnOptions options = {}, String[] environment = {},
+                  ProcessStdio in = DEFAULT, ProcessStdio out = DEFAULT, ProcessStdio err = DEFAULT) @if(env::WIN32 || env::POSIX)
 {
+	update_default(&in, &out, &err, !!(options & INHERIT_STDIO));
+
+$if env::WIN32:
 	Win32_DWORD flags = win32::CREATE_UNICODE_ENVIRONMENT;
 	Win32_PROCESS_INFORMATION process_info;
 	Win32_SECURITY_ATTRIBUTES sa_attr = { Win32_SECURITY_ATTRIBUTES::size, null, 1 };
@@ -106,15 +104,15 @@ fn Process? spawn(String[] command_line, SpawnOptions options = {}, String[] env
 
 	if (options & NO_WINDOW) flags |= win32::CREATE_NO_WINDOW;
 
-	// Backwards compatibility
-	if (options & INHERIT_STDIO_MASK) stdio = { INHERIT, INHERIT, INHERIT };
 
 	CFile stdin, stdout, stderr;
 	void* rd, wr;
 	void* event_output, event_error;
 
-	switch (stdio.stdin.kind)
+	switch (in.action)
 	{
+		case DEFAULT:
+			unreachable();
 		case CAPTURE:
 			if (!win32::createPipe(&rd, &wr, &sa_attr, 0)) return FAILED_TO_CREATE_PIPE~;
 			if (!win32::setHandleInformation(wr, win32::HANDLE_FLAG_INHERIT, 0)) return FAILED_TO_CREATE_PIPE~;
@@ -127,13 +125,15 @@ fn Process? spawn(String[] command_line, SpawnOptions options = {}, String[] env
 			}
 			start_info.hStdInput = rd;
 		case BIND:
-			start_info.hStdInput = stdio.stdin.fd;
+			start_info.hStdInput = in.fd;
 		case INHERIT:
 			start_info.hStdInput = win32::getStdHandle(win32::STD_INPUT_HANDLE);
 	}
 
-	switch (stdio.stdout.kind)
+	switch (out.action)
 	{
+		case DEFAULT:
+			unreachable();
 		case CAPTURE:
 			if (options & ASYNC_OUTPUT)
 			{
@@ -155,7 +155,7 @@ fn Process? spawn(String[] command_line, SpawnOptions options = {}, String[] env
 
 			start_info.hStdOutput = wr;
 		case BIND:
-			start_info.hStdOutput = stdio.stdout.fd;
+			start_info.hStdOutput = out.fd;
 		case INHERIT:
 			start_info.hStdOutput = win32::getStdHandle(win32::STD_OUTPUT_HANDLE);
 	}
@@ -167,8 +167,10 @@ fn Process? spawn(String[] command_line, SpawnOptions options = {}, String[] env
 	}
 	else
 	{
-		switch (stdio.stderr.kind)
+		switch (err.action)
 		{
+			case DEFAULT:
+				unreachable();
 			case CAPTURE:
 				if (options & ASYNC_OUTPUT)
 				{
@@ -189,7 +191,7 @@ fn Process? spawn(String[] command_line, SpawnOptions options = {}, String[] env
 				}
 				start_info.hStdError = wr;
 			case BIND:
-				start_info.hStdError = stdio.stderr.fd;
+				start_info.hStdError = err.fd;
 			case INHERIT:
 				start_info.hStdError = win32::getStdHandle(win32::STD_ERROR_HANDLE);
 		}
@@ -230,69 +232,56 @@ fn Process? spawn(String[] command_line, SpawnOptions options = {}, String[] env
 	// We don't need the handle of the primary thread in the called process.
 	win32::closeHandle(process_info.hThread);
 
-	if (stdio.stdout.kind == CAPTURE) win32::closeHandle(start_info.hStdOutput);
-	if (stdio.stderr.kind == CAPTURE && start_info.hStdOutput != start_info.hStdError)
+	if (out.action == CAPTURE) win32::closeHandle(start_info.hStdOutput);
+	if (err.action == CAPTURE && start_info.hStdOutput != start_info.hStdError)
 	{
 		win32::closeHandle(start_info.hStdError);
 	}
 
 
 	return {
 		.hProcess = process_info.hProcess,
-		.hStdInput = stdio.stdin.kind == CAPTURE ? start_info.hStdInput : null,
+		.hStdInput = in.action == CAPTURE ? start_info.hStdInput : null,
 		.hEventOutput = event_output,
 		.hEventError = event_error,
 		.stdin_file = stdin,
 		.stdout_file = stdout,
 		.stderr_file = stderr,
 		.is_alive = true,
 	};
-}
-
-
-
-
-<*
- @require !environment || !(options & INHERIT_ENV)
-*>
-fn Process? spawn(String[] command_line, SpawnOptions options = { }, String[] environment = {}, ProcessStdioSet stdio = {}) @if(env::POSIX)
-{
-	CInt[2] stdinfd;
-	CInt[2] stdoutfd;
-	CInt[2] stderrfd;
-	CFile stdin = null;
-	CFile stdout = null;
-	CFile stderr = null;
-
+$else
 	Posix_spawn_file_actions_t actions;
 	if (posix::spawn_file_actions_init(&actions)) return FAILED_TO_INITIALIZE_ACTIONS~;
 	defer posix::spawn_file_actions_destroy(&actions);
 
-	// Backwards compatibility
-	if (options & INHERIT_STDIO_MASK) stdio = { INHERIT, INHERIT, INHERIT };
-
-
 	// We should set FD_CLOEXEC to prevent leaking pipe handles between concurrent spawns
 	const int F_SETFD = 2;
 	const int FD_CLOEXEC = 1;
 
-	switch (stdio.stdin.kind)
+	CInt[2] stdinfd, stdoutfd, stderrfd;
+	CFile stdin, stdout, stderr;
+
+	switch (in.action)
 	{
-		case CAPTURE:	
+		case DEFAULT:
+			unreachable();
+		case CAPTURE:
 			if (posix::pipe(&stdinfd)) return FAILED_TO_OPEN_STDIN~;
 			os::fcntl((NativeSocket)stdinfd[0], F_SETFD, FD_CLOEXEC);
 			os::fcntl((NativeSocket)stdinfd[1], F_SETFD, FD_CLOEXEC);
 			if (posix::spawn_file_actions_adddup2(&actions, stdinfd[0], libc::STDIN_FD)) return FAILED_TO_OPEN_STDIN~;
 		case BIND:
-			if (posix::spawn_file_actions_adddup2(&actions, stdio.stdin.fd, libc::STDIN_FD)) return FAILED_TO_BIND_STDIN~;
+			if (posix::spawn_file_actions_adddup2(&actions, in.fd, libc::STDIN_FD)) return FAILED_TO_BIND_STDIN~;
 		case INHERIT:
 			break;
 	}
 
-	switch (stdio.stdout.kind)
+	switch (out.action)
 	{
+		case DEFAULT:
+			unreachable();
 		case CAPTURE:
-			if (posix::pipe(&stdoutfd)) return FAILED_TO_OPEN_STDOUT~;	
+			if (posix::pipe(&stdoutfd)) return FAILED_TO_OPEN_STDOUT~;
 			os::fcntl((NativeSocket)stdoutfd[0], F_SETFD, FD_CLOEXEC);
 			os::fcntl((NativeSocket)stdoutfd[1], F_SETFD, FD_CLOEXEC);
 
@@ -303,7 +292,7 @@ fn Process? spawn(String[] command_line, SpawnOptions options = { }, String[] en
 			}
 			if (posix::spawn_file_actions_adddup2(&actions, stdoutfd[1], libc::STDOUT_FD)) return FAILED_TO_OPEN_STDOUT~;
 		case BIND:
-			if (posix::spawn_file_actions_adddup2(&actions, stdio.stdout.fd, libc::STDOUT_FD)) return FAILED_TO_BIND_STDOUT~;
+			if (posix::spawn_file_actions_adddup2(&actions, out.fd, libc::STDOUT_FD)) return FAILED_TO_BIND_STDOUT~;
 		case INHERIT:
 			break;
 	}
@@ -314,21 +303,23 @@ fn Process? spawn(String[] command_line, SpawnOptions options = { }, String[] en
 	}
 	else
 	{
-		switch (stdio.stderr.kind)
+		switch (err.action)
 		{
+			case DEFAULT:
+				unreachable();
 			case CAPTURE:
 				if (posix::pipe(&stderrfd)) return FAILED_TO_OPEN_STDERR~;
 				os::fcntl((NativeSocket)stderrfd[0], F_SETFD, FD_CLOEXEC);
 				os::fcntl((NativeSocket)stderrfd[1], F_SETFD, FD_CLOEXEC);
-				
+
 				if (options & ASYNC_OUTPUT)
 				{
 					((NativeSocket)stderrfd[0]).set_non_blocking(true)!;
 					((NativeSocket)stderrfd[1]).set_non_blocking(true)!;
 				}
 				if (posix::spawn_file_actions_adddup2(&actions, stderrfd[1], libc::STDERR_FD)) return FAILED_TO_OPEN_STDERR~;
 			case BIND:
-				if (posix::spawn_file_actions_adddup2(&actions, stdio.stderr.fd, libc::STDERR_FD)) return FAILED_TO_BIND_STDERR~;
+				if (posix::spawn_file_actions_adddup2(&actions, err.fd, libc::STDERR_FD)) return FAILED_TO_BIND_STDERR~;
 			case INHERIT:
 				break;
 		}
@@ -350,17 +341,17 @@ fn Process? spawn(String[] command_line, SpawnOptions options = { }, String[] en
 	};
 
 	// Only set up file handles for when stdio is captured
-	if (stdio.stdin.kind  == CAPTURE)
+	if (in.action  == CAPTURE)
 	{
 		libc::close(stdinfd[0]);
 		stdin = libc::fdopen(stdinfd[1],  "wb");
 	}
-	if (stdio.stdout.kind == CAPTURE)
+	if (out.action == CAPTURE)
 	{
 		libc::close(stdoutfd[1]);
 		stdout = libc::fdopen(stdoutfd[0], "rb");
 	}
-	if (stdio.stderr.kind == CAPTURE)
+	if (err.action == CAPTURE)
 	{
 		if (options & STDERR_TO_STDOUT)
 		{
@@ -381,8 +372,13 @@ fn Process? spawn(String[] command_line, SpawnOptions options = { }, String[] en
 		.child = child,
 		.is_alive = true,
 	};
+$endif
 }
 
+
+
+
+
 fn CInt? Process.join(&self) @if(env::POSIX)
 {
 	if (self.stdin_file)
@@ -434,7 +430,7 @@ fn bool Process.destroy(&self)
 {
 	if (self.stdin_file) libc::fclose(self.stdin_file);
 	if (self.stdout_file) libc::fclose(self.stdout_file);
-    if (self.stderr_file && self.stderr_file != self.stdout_file) libc::fclose(self.stderr_file);
+	if (self.stderr_file && self.stderr_file != self.stdout_file) libc::fclose(self.stderr_file);
 	self.stdin_file = self.stdout_file = self.stderr_file = null;
 	$if env::WIN32:
 		if (self.hProcess) win32::closeHandle(self.hProcess);
@@ -630,3 +626,11 @@ fn ZString* copy_env(Allocator mem, String[] environment) @local @inline @if(env
 	}
 	return copy;
 }
+
+macro update_default(ProcessStdio* in, ProcessStdio* out, ProcessStdio* err, bool inherit_by_default) @local
+{
+	ProcessStdioAction action = inherit_by_default ? INHERIT : CAPTURE;
+	if (in.action == DEFAULT) in.action = action;
+	if (out.action == DEFAULT) out.action = action;
+	if (err.action == DEFAULT) err.action = action;
+}

releasenotes.md

@@ -18,7 +18,8 @@
 - `ini::parse` and related takes an `error_line` argument to identify the line with error.
 - JSON marshaling will return INVALID_NUMBER when encountering a inf or NaN for a float.
 - JSON decoding will reject `1.` literals.
-
+- `spawn` now allows binding I/O and using different settings per pipe.
+ 
 ### Fixes
 - `@volatile_store` on arrays were sometimes incorrectly lowered.
 - NPOT vectors as associated variables were incorrectly lowered on load. #3228