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

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
}