Initial project import

tools/v/vlib/os/pipe.c.v

@@ -0,0 +1,213 @@
+module os
+
+fn C._dup(fd i32) i32
+fn C._dup2(fd1 i32, fd2 i32) i32
+fn C._pipe(fds &int, size u32, mode i32) i32
+fn C.dup(fd i32) i32
+
+const fd_stdout = $if windows { 1 } $else { C.STDOUT_FILENO }
+const fd_stderr = $if windows { 2 } $else { C.STDERR_FILENO }
+
+// fd_dup duplicates a file descriptor
+pub fn fd_dup(fd int) int {
+	return $if windows { C._dup(fd) } $else { C.dup(fd) }
+}
+
+// fd_dup2 duplicates file descriptor `fd1` to descriptor number `fd2`
+// If `fd2` is already open, it is closed first before being reused.
+// Returns the new file descriptor on success, or -1 on error.
+pub fn fd_dup2(fd1 int, fd2 int) int {
+	return $if windows { C._dup2(fd1, fd2) } $else { C.dup2(fd1, fd2) }
+}
+
+// Pipe represents a bidirectional communication channel
+@[noinit]
+pub struct Pipe {
+pub mut:
+	read_fd  int = -1
+	write_fd int = -1
+}
+
+// pipe creates a new pipe for inter-process communication
+pub fn pipe() !Pipe {
+	mut fds := [2]int{}
+	$if windows {
+		if C._pipe(&fds[0], 0, 0) == -1 {
+			return error('Failed to create pipe')
+		}
+	} $else {
+		if C.pipe(&fds[0]) == -1 {
+			return error('Failed to create pipe')
+		}
+	}
+
+	return Pipe{
+		read_fd:  fds[0]
+		write_fd: fds[1]
+	}
+}
+
+// close closes the pipe and releases associated resources
+pub fn (mut p Pipe) close() {
+	if p.read_fd != -1 {
+		fd_close(p.read_fd)
+		p.read_fd = -1
+	}
+	if p.write_fd != -1 {
+		fd_close(p.write_fd)
+		p.write_fd = -1
+	}
+}
+
+// read reads data from the pipe into the provided buffer
+pub fn (p &Pipe) read(mut buffer []u8) !int {
+	result := C.read(p.read_fd, buffer.data, buffer.len)
+	if result == -1 {
+		return error('Read failed')
+	}
+	return int(result)
+}
+
+// write writes data from the buffer to the pipe
+pub fn (p &Pipe) write(buffer []u8) !int {
+	result := C.write(p.write_fd, buffer.data, buffer.len)
+	if result == -1 {
+		return error('Write failed')
+	}
+	return int(result)
+}
+
+// write_string writes data from the string to the pipe
+pub fn (p &Pipe) write_string(s string) !int {
+	result := C.write(p.write_fd, voidptr(s.str), s.len)
+	if result == -1 {
+		return error('Write failed')
+	}
+	return int(result)
+}
+
+// slurp reads all data from the pipe until EOF
+pub fn (mut p Pipe) slurp() []string {
+	// Close write end to send EOF signal to the pipe
+	fd_close(p.write_fd)
+	p.write_fd = -1
+	result := fd_slurp(p.read_fd)
+	fd_close(p.read_fd)
+	p.read_fd = -1
+	return result
+}
+
+// IOCapture manages redirection of standard output and error streams
+@[noinit]
+pub struct IOCapture {
+pub mut:
+	stdout Pipe
+	stderr Pipe
+mut:
+	original_stdout_fd int = -1
+	original_stderr_fd int = -1
+}
+
+// stdio_capture starts capturing stdout and stderr by redirecting them to pipes
+// Example:
+// ```v
+//    	import os
+//    	unbuffer_stdout()
+//    	mut cap := os.stdio_capture()!
+//    	println('hello println')
+//    	eprintln('hello eprintln')
+//    	cap.stop()
+//    	sout := cap.stdout.slurp()
+//    	serr := cap.stderr.slurp()
+//    	cap.close()
+//    	assert sout == ['hello println\n']
+//    	assert serr == ['hello eprintln\n']
+// ```
+// or
+// ```v
+//    	import os
+//    	unbuffer_stdout()
+//    	mut cap := os.stdio_capture()!
+//    	println('hello println')
+//    	eprintln('hello eprintln')
+//    	eprintln('World eprintln')
+//    	println('World println')
+//    	sout, serr := cap.finish()
+//    	assert sout == ['hello println\nWorld println\n']
+//    	assert serr == ['hello eprintln\nWorld eprintln\n']
+// ```
+pub fn stdio_capture() !IOCapture {
+	mut c := IOCapture{}
+	mut pipe_stdout := pipe()!
+	mut pipe_stderr := pipe()!
+
+	flush_stdout()
+	flush_stderr()
+
+	// Save original file descriptors
+	c.original_stdout_fd = fd_dup(fd_stdout)
+	c.original_stderr_fd = fd_dup(fd_stderr)
+
+	// Redirect stdout to pipe
+	if fd_dup2(pipe_stdout.write_fd, fd_stdout) == -1 {
+		pipe_stdout.close()
+		pipe_stderr.close()
+		return error('Failed to redirect stdout')
+	}
+
+	// Redirect stderr to pipe
+	if fd_dup2(pipe_stderr.write_fd, fd_stderr) == -1 {
+		fd_dup2(c.original_stdout_fd, fd_stdout) // Restore stdout
+		pipe_stdout.close()
+		pipe_stderr.close()
+		return error('Failed to redirect stderr')
+	}
+
+	// Close original write ends (duplicated by dup2)
+	fd_close(pipe_stdout.write_fd)
+	fd_close(pipe_stderr.write_fd)
+
+	pipe_stdout.write_fd = -1
+	pipe_stderr.write_fd = -1
+
+	// Store pipes for later reading
+	c.stdout = pipe_stdout
+	c.stderr = pipe_stderr
+	return c
+}
+
+// stop restores the original stdout and stderr streams
+// This should be called to resume normal console output
+pub fn (mut c IOCapture) stop() {
+	flush_stdout()
+	flush_stderr()
+
+	// Restore original stdout
+	if c.original_stdout_fd != -1 {
+		fd_dup2(c.original_stdout_fd, fd_stdout)
+		fd_close(c.original_stdout_fd)
+		c.original_stdout_fd = -1
+	}
+
+	// Restore original stderr
+	if c.original_stderr_fd != -1 {
+		fd_dup2(c.original_stderr_fd, fd_stderr)
+		fd_close(c.original_stderr_fd)
+		c.original_stderr_fd = -1
+	}
+}
+
+// close releases all resources associated with the capture
+pub fn (mut c IOCapture) close() {
+	c.stdout.close()
+	c.stderr.close()
+}
+
+// finish stops capturing, reads all captured data, and releases resources
+pub fn (mut c IOCapture) finish() ([]string, []string) {
+	c.stop()
+	stdout_str := c.stdout.slurp()
+	stderr_str := c.stderr.slurp()
+	c.close()
+	return stdout_str, stderr_str
+}