rust/src/lib/run_program.rs

127 lines
3.6 KiB
Rust
Raw Normal View History

import str::sbuf;
2011-07-18 23:07:33 -05:00
export program;
export run_program;
export start_program;
export program_output;
export spawn_process;
2011-07-18 23:07:33 -05:00
native "rust" mod rustrt {
2011-08-12 02:01:25 -05:00
fn rust_run_program(argv: *sbuf, in_fd: int, out_fd: int, err_fd: int) ->
2011-07-27 07:19:39 -05:00
int;
}
2011-08-12 00:31:45 -05:00
fn arg_vec(prog: str, args: &[str]) -> [sbuf] {
let argptrs = [str::buf(prog)];
for arg: str in args { argptrs += [str::buf(arg)]; }
argptrs += [0 as sbuf];
ret argptrs;
}
2011-08-24 20:40:57 -05:00
fn spawn_process(prog: &istr, args: &[istr], in_fd: int, out_fd: int,
2011-07-27 07:19:39 -05:00
err_fd: int) -> int {
2011-08-24 20:40:57 -05:00
let prog = istr::to_estr(prog);
let args = istr::to_estrs(args);
// Note: we have to hold on to this vector reference while we hold a
// pointer to its buffer
2011-07-27 07:19:39 -05:00
let argv = arg_vec(prog, args);
let pid =
rustrt::rust_run_program(vec::to_ptr(argv), in_fd, out_fd, err_fd);
2011-07-18 23:07:33 -05:00
ret pid;
}
2011-08-24 20:40:57 -05:00
fn run_program(prog: &istr, args: &[istr]) -> int {
2011-07-18 23:07:33 -05:00
ret os::waitpid(spawn_process(prog, args, 0, 0, 0));
}
type program =
obj {
fn get_id() -> int;
2011-08-11 21:14:38 -05:00
fn input() -> io::writer;
fn output() -> io::reader;
fn err() -> io::reader;
fn close_input();
fn finish() -> int;
fn destroy();
};
resource program_res(p: program) { p.destroy(); }
2011-08-24 20:40:57 -05:00
fn start_program(prog: &istr, args: &[istr]) -> @program_res {
2011-07-27 07:19:39 -05:00
let pipe_input = os::pipe();
let pipe_output = os::pipe();
2011-07-28 23:15:56 -05:00
let pipe_err = os::pipe();
let pid =
spawn_process(prog, args, pipe_input.in, pipe_output.out,
pipe_err.out);
2011-07-18 23:07:33 -05:00
2011-07-27 07:19:39 -05:00
if pid == -1 { fail; }
os::libc::close(pipe_input.in);
os::libc::close(pipe_output.out);
2011-07-28 23:15:56 -05:00
os::libc::close(pipe_err.out);
2011-07-27 07:19:39 -05:00
obj new_program(pid: int,
mutable in_fd: int,
out_file: os::libc::FILE,
2011-07-28 23:15:56 -05:00
err_file: os::libc::FILE,
2011-07-27 07:19:39 -05:00
mutable finished: bool) {
fn get_id() -> int { ret pid; }
2011-08-11 21:14:38 -05:00
fn input() -> io::writer {
ret io::new_writer(io::fd_buf_writer(in_fd, option::none));
}
2011-08-11 21:14:38 -05:00
fn output() -> io::reader {
ret io::new_reader(io::FILE_buf_reader(out_file, option::none));
}
2011-08-11 21:14:38 -05:00
fn err() -> io::reader {
ret io::new_reader(io::FILE_buf_reader(err_file, option::none));
2011-07-28 23:15:56 -05:00
}
fn close_input() {
2011-07-27 07:19:39 -05:00
let invalid_fd = -1;
if in_fd != invalid_fd {
os::libc::close(in_fd);
in_fd = invalid_fd;
}
}
2011-04-19 15:35:49 -05:00
fn finish() -> int {
2011-07-27 07:19:39 -05:00
if finished { ret 0; }
finished = true;
self.close_input();
ret os::waitpid(pid);
}
fn destroy() {
self.finish();
os::libc::fclose(out_file);
2011-07-28 23:15:56 -05:00
os::libc::fclose(err_file);
}
}
ret @program_res(new_program(pid, pipe_input.out,
os::fd_FILE(pipe_output.in),
os::fd_FILE(pipe_err.in), false));
}
2011-08-11 21:14:38 -05:00
fn read_all(rd: &io::reader) -> str {
2011-07-27 07:19:39 -05:00
let buf = "";
2011-07-28 23:15:56 -05:00
while !rd.eof() {
let bytes = rd.read_bytes(4096u);
buf += str::unsafe_from_bytes(bytes);
}
2011-07-28 23:15:56 -05:00
ret buf;
}
2011-08-24 20:40:57 -05:00
fn program_output(prog: &istr, args: &[istr]) ->
{status: int, out: str, err: str} {
2011-07-28 23:15:56 -05:00
let pr = start_program(prog, args);
pr.close_input();
ret {status: pr.finish(),
out: read_all(pr.output()),
err: read_all(pr.err())};
}
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
// End: