code review 4253052: os, syscall: add ProcAttributes type. Change StartProce...

src/cmd/godoc/main.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // godoc: Go Documentation Server
 
 // Web server tree:
 //
 //      http://godoc/           main landing page
 //      http://godoc/doc/       serve from $GOROOT/doc - spec, mem, tutorial, etc.
@@ skipping 18 matching lines @@
         "bytes"
         _ "expvar" // to serve /debug/vars
         "flag"
         "fmt"
         "go/ast"
         "http"
         _ "http/pprof" // to serve /debug/pprof/*
         "io"
         "log"
         "os"
-        pathutil "path"
+        "path/filepath"
         "regexp"
         "runtime"
         "strings"
         "time"
 )
 
 const defaultAddr = ":6060" // default webserver address
 
 var (
         // periodic sync
@@ skipping 26 matching lines @@
         if err != nil {
                 log.Printf("os.Pipe(): %v", err)
                 return 2
         }
 
         bin := args[0]
         fds := []*os.File{nil, w, w}
         if *verbose {
                 log.Printf("executing %v", args)
         }
-        var attrs os.ProcAttributes
-        attrs.Chdir(*goroot)
-        p, err := os.StartProcess(bin, args, os.Environ(), fds, &attrs)
+        p, err := os.StartProcess(bin, args, &os.ProcAttr{Files: fds, Dir: *goroot})
         defer r.Close()
         w.Close()
         if err != nil {
                 log.Printf("os.StartProcess(%q): %v", bin, err)
                 return 2
         }
         defer p.Release()
 
         var buf bytes.Buffer
         io.Copy(&buf, r)
@@ skipping 210 matching lines @@
                         io.Copy(os.Stdout, res.Body)
                 }
                 return
         }
 
         // determine paths
         path := flag.Arg(0)
         if len(path) > 0 && path[0] == '.' {
                 // assume cwd; don't assume -goroot
                 cwd, _ := os.Getwd() // ignore errors
-                path = pathutil.Join(cwd, path)
+                path = filepath.Join(cwd, path)
         }
         relpath := path
         abspath := path
-        if !pathutil.IsAbs(path) {
+        if !filepath.IsAbs(path) {
                 abspath = absolutePath(path, pkgHandler.fsRoot)
         } else {
-                relpath = relativePath(path)
+                relpath = relativeURL(path)
         }
 
         var mode PageInfoMode
         if *srcMode {
                 // only filter exports if we don't have explicit command-line filter arguments
                 if flag.NArg() == 1 {
                         mode |= exportsOnly
                 }
         } else {
                 mode = exportsOnly | genDoc
         }
         // TODO(gri): Provide a mechanism (flag?) to select a package
         //            if there are multiple packages in a directory.
         info := pkgHandler.getPageInfo(abspath, relpath, "", mode)
 
         if info.IsEmpty() {
                 // try again, this time assume it's a command
-                if !pathutil.IsAbs(path) {
+                if !filepath.IsAbs(path) {
                         abspath = absolutePath(path, cmdHandler.fsRoot)
                 }
                 cmdInfo := cmdHandler.getPageInfo(abspath, relpath, "", mode)
                 // only use the cmdInfo if it actually contains a result
                 // (don't hide errors reported from looking up a package)
                 if !cmdInfo.IsEmpty() {
                         info = cmdInfo
                 }
         }
         if info.Err != nil {
@@ skipping 30 matching lines @@
 
                 case info.PDoc != nil:
                         info.PDoc.Filter(filter)
                 }
         }
 
         if err := packageText.Execute(os.Stdout, info); err != nil {
                 log.Printf("packageText.Execute: %s", err)
         }
 }