func RunExternalDump(cmd, wd string, argv []string, dump io.Writer) (err os.Error) {
var p *exec.Cmd
p, err = exec.Run(cmd, argv, nil, wd, exec.PassThrough, exec.Pipe, exec.PassThrough)
if err != nil {
return
}
if p != nil {
src := p.Stdout
buffer := make([]byte, 1024)
for {
n, cpErr := src.Read(buffer)
if cpErr != nil {
break
}
_, cpErr = dump.Write(buffer[0:n])
if cpErr != nil {
break
}
}
var wmsg *os.Waitmsg
wmsg, err = p.Wait(0)
if wmsg.ExitStatus() != 0 {
err = os.NewError(fmt.Sprintf("%v: %s\n", argv, wmsg.String()))
return
}
if err != nil {
return
}
}
return
}
func build(gcfile string, opts []string, proFileName string, files []string, envv []string, dir string) (status syscall.WaitStatus, err os.Error) {
arg := []string{gcfile, "-o", proFileName}
for _, v := range opts {
arg = append(arg, v)
}
for _, v := range files {
arg = append(arg, string(v))
}
fmt.Println("\t", arg)
var cmd *exec.Cmd
cmd, err = exec.Run(gcfile, arg[:], envv[:], dir, 0, 1, 2)
if err != nil {
fmt.Printf("Error, %s", err)
return
}
defer cmd.Close()
var wait *os.Waitmsg
wait, err = cmd.Wait(0)
if err != nil {
fmt.Printf("Error, %s", err)
return
}
status = wait.WaitStatus
return
}
// run runs the command argv, resolving argv[0] if necessary by searching $PATH.
// It provides input on standard input to the command.
func run(argv []string, input []byte) (out string, err os.Error) {
if len(argv) < 1 {
err = os.EINVAL
goto Error
}
prog, ok := lookPathCache[argv[0]]
if !ok {
prog, err = exec.LookPath(argv[0])
if err != nil {
goto Error
}
lookPathCache[argv[0]] = prog
}
// fmt.Fprintf(os.Stderr, "%v\n", argv);
var cmd *exec.Cmd
if len(input) == 0 {
cmd, err = exec.Run(prog, argv, os.Environ(), "", exec.DevNull, exec.Pipe, exec.MergeWithStdout)
if err != nil {
goto Error
}
} else {
cmd, err = exec.Run(prog, argv, os.Environ(), "", exec.Pipe, exec.Pipe, exec.MergeWithStdout)
if err != nil {
goto Error
}
go func() {
cmd.Stdin.Write(input)
cmd.Stdin.Close()
}()
}
defer cmd.Close()
var buf bytes.Buffer
_, err = io.Copy(&buf, cmd.Stdout)
out = buf.String()
if err != nil {
cmd.Wait(0)
goto Error
}
w, err := cmd.Wait(0)
if err != nil {
goto Error
}
if !w.Exited() || w.ExitStatus() != 0 {
err = w
goto Error
}
return
Error:
err = &runError{copy(argv), err}
return
}
func StdExecve(argv []string, stopOnTrouble bool) bool {
var err os.Error
var cmd *exec.Cmd
switch len(argv) {
case 0:
if stopOnTrouble {
log.Fatalf("[ERROR] len(argv) == 0\n")
}
return false
case 1:
cmd = exec.Command(argv[0])
default:
cmd = exec.Command(argv[0], argv[1:]...)
}
// pass-through
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
cmd.Stdin = os.Stdin
err = cmd.Start()
if err != nil {
if stopOnTrouble {
log.Fatalf("[ERROR] %s\n", err)
} else {
log.Printf("[ERROR] %s\n", err)
return false
}
}
err = cmd.Wait()
if err != nil {
if stopOnTrouble {
log.Fatalf("[ERROR] %s\n", err)
} else {
log.Printf("[ERROR] %s\n", err)
return false
}
}
return true
}
func run(argv []string, stdin, stdout, stderr int) (out string, err os.Error) {
if len(argv) < 1 {
err = os.EINVAL
goto Error
}
var cmd *exec.Cmd
cmd, err = exec.Run(argv[0], argv, os.Environ(), "", stdin, stdout, stderr)
if err != nil {
goto Error
}
defer cmd.Close()
var buf bytes.Buffer
_, err = io.Copy(&buf, cmd.Stdout)
out = buf.String()
if err != nil {
cmd.Wait(0)
goto Error
}
w, err := cmd.Wait(0)
if err != nil {
goto Error
}
if !w.Exited() || w.ExitStatus() != 0 {
err = w
goto Error
}
return
Error:
err = &runError{copy(argv), err}
return
}
func pack(pkfile string, target string, ofile string, envv []string, dir string) (status syscall.WaitStatus, err os.Error) {
arg := []string{pkfile, "grc", target, ofile}
fmt.Println("\t", arg)
var cmd *exec.Cmd
cmd, err = exec.Run(pkfile, arg[:], envv[:], dir, 0, 1, 2)
if err != nil {
fmt.Printf("Error, %s", err)
return
}
defer cmd.Close()
var wait *os.Waitmsg
wait, err = cmd.Wait(0)
if err != nil {
fmt.Printf("Error, %s", err)
return
}
status = wait.WaitStatus
return
}
func link(glfile string, opts []string, target string, ofile string, envv []string, dir string) (status syscall.WaitStatus, err os.Error) {
arg := []string{glfile, "-o", target}
for _, v := range opts {
arg = append(arg, v)
}
arg = append(arg, ofile)
fmt.Println("\t", arg)
var cmd *exec.Cmd
cmd, err = exec.Run(glfile, arg[:], envv[:], dir, 0, 1, 2)
if err != nil {
fmt.Printf("Error, %s", err)
return
}
defer cmd.Close()
var wait *os.Waitmsg
wait, err = cmd.Wait(0)
if err != nil {
fmt.Printf("Error, %s", err)
return
}
status = wait.WaitStatus
return
}
