| // Copyright 2011 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. |
| |
| package main |
| |
| import ( |
| "bytes" |
| "flag" |
| "fmt" |
| "go/build" |
| "io" |
| "log" |
| "os" |
| "os/exec" |
| "path" |
| "path/filepath" |
| "regexp" |
| "strings" |
| "sync" |
| "text/template" |
| "unicode" |
| "unicode/utf8" |
| ) |
| |
| // A Command is an implementation of a go command |
| // like go build or go fix. |
| type Command struct { |
| // Run runs the command. |
| // The args are the arguments after the command name. |
| Run func(cmd *Command, args []string) |
| |
| // UsageLine is the one-line usage message. |
| // The first word in the line is taken to be the command name. |
| UsageLine string |
| |
| // Short is the short description shown in the 'go help' output. |
| Short string |
| |
| // Long is the long message shown in the 'go help <this-command>' output. |
| Long string |
| |
| // Flag is a set of flags specific to this command. |
| Flag flag.FlagSet |
| |
| // CustomFlags indicates that the command will do its own |
| // flag parsing. |
| CustomFlags bool |
| } |
| |
| // Name returns the command's name: the first word in the usage line. |
| func (c *Command) Name() string { |
| name := c.UsageLine |
| i := strings.Index(name, " ") |
| if i >= 0 { |
| name = name[:i] |
| } |
| return name |
| } |
| |
| func (c *Command) Usage() { |
| fmt.Fprintf(os.Stderr, "usage: %s\n\n", c.UsageLine) |
| fmt.Fprintf(os.Stderr, "%s\n", strings.TrimSpace(c.Long)) |
| os.Exit(2) |
| } |
| |
| // Commands lists the available commands and help topics. |
| // The order here is the order in which they are printed by 'go help'. |
| var commands = []*Command{ |
| cmdBuild, |
| cmdClean, |
| cmdDoc, |
| cmdFix, |
| cmdFmt, |
| cmdGet, |
| cmdInstall, |
| cmdList, |
| cmdRun, |
| cmdTest, |
| cmdTool, |
| cmdVersion, |
| cmdVet, |
| |
| helpGopath, |
| helpImportpath, |
| helpRemote, |
| helpTestflag, |
| helpTestfunc, |
| } |
| |
| var exitStatus = 0 |
| var exitMu sync.Mutex |
| |
| func setExitStatus(n int) { |
| exitMu.Lock() |
| if exitStatus < n { |
| exitStatus = n |
| } |
| exitMu.Unlock() |
| } |
| |
| func main() { |
| flag.Usage = usage |
| flag.Parse() |
| log.SetFlags(0) |
| |
| args := flag.Args() |
| if len(args) < 1 { |
| usage() |
| } |
| |
| if args[0] == "help" { |
| help(args[1:]) |
| return |
| } |
| |
| for _, cmd := range commands { |
| if cmd.Name() == args[0] && cmd.Run != nil { |
| cmd.Flag.Usage = func() { cmd.Usage() } |
| if cmd.CustomFlags { |
| args = args[1:] |
| } else { |
| cmd.Flag.Parse(args[1:]) |
| args = cmd.Flag.Args() |
| } |
| cmd.Run(cmd, args) |
| exit() |
| return |
| } |
| } |
| |
| fmt.Fprintf(os.Stderr, "Unknown command %#q\n\n", args[0]) |
| usage() |
| } |
| |
| var usageTemplate = `Go is a tool for managing Go source code. |
| |
| Usage: go command [arguments] |
| |
| The commands are: |
| {{range .}}{{if .Run}} |
| {{.Name | printf "%-11s"}} {{.Short}}{{end}}{{end}} |
| |
| Use "go help [command]" for more information about a command. |
| |
| Additional help topics: |
| {{range .}}{{if not .Run}} |
| {{.Name | printf "%-11s"}} {{.Short}}{{end}}{{end}} |
| |
| Use "go help [topic]" for more information about that topic. |
| |
| ` |
| |
| var helpTemplate = `{{if .Run}}usage: go {{.UsageLine}} |
| |
| {{end}}{{.Long | trim}} |
| ` |
| |
| var documentationTemplate = `// Copyright 2011 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. |
| |
| /* |
| {{range .}}{{if .Short}}{{.Short | capitalize}} |
| |
| {{end}}{{if .Run}}Usage: |
| |
| go {{.UsageLine}} |
| |
| {{end}}{{.Long | trim}} |
| |
| |
| {{end}}*/ |
| package documentation |
| |
| // NOTE: cmdDoc is in fmt.go. |
| ` |
| |
| // tmpl executes the given template text on data, writing the result to w. |
| func tmpl(w io.Writer, text string, data interface{}) { |
| t := template.New("top") |
| t.Funcs(template.FuncMap{"trim": strings.TrimSpace, "capitalize": capitalize}) |
| template.Must(t.Parse(text)) |
| if err := t.Execute(w, data); err != nil { |
| panic(err) |
| } |
| } |
| |
| func capitalize(s string) string { |
| if s == "" { |
| return s |
| } |
| r, n := utf8.DecodeRuneInString(s) |
| return string(unicode.ToTitle(r)) + s[n:] |
| } |
| |
| func printUsage(w io.Writer) { |
| tmpl(w, usageTemplate, commands) |
| } |
| |
| func usage() { |
| printUsage(os.Stderr) |
| os.Exit(2) |
| } |
| |
| // help implements the 'help' command. |
| func help(args []string) { |
| if len(args) == 0 { |
| printUsage(os.Stdout) |
| // not exit 2: succeeded at 'go help'. |
| return |
| } |
| if len(args) != 1 { |
| fmt.Fprintf(os.Stderr, "usage: go help command\n\nToo many arguments given.\n") |
| os.Exit(2) // failed at 'go help' |
| } |
| |
| arg := args[0] |
| |
| // 'go help documentation' generates doc.go. |
| if arg == "documentation" { |
| buf := new(bytes.Buffer) |
| printUsage(buf) |
| usage := &Command{Long: buf.String()} |
| tmpl(os.Stdout, documentationTemplate, append([]*Command{usage}, commands...)) |
| return |
| } |
| |
| for _, cmd := range commands { |
| if cmd.Name() == arg { |
| tmpl(os.Stdout, helpTemplate, cmd) |
| // not exit 2: succeeded at 'go help cmd'. |
| return |
| } |
| } |
| |
| fmt.Fprintf(os.Stderr, "Unknown help topic %#q. Run 'go help'.\n", arg) |
| os.Exit(2) // failed at 'go help cmd' |
| } |
| |
| // importPaths returns the import paths to use for the given command line. |
| func importPaths(args []string) []string { |
| if len(args) == 0 { |
| return []string{"."} |
| } |
| var out []string |
| for _, a := range args { |
| if isLocalPath(a) && strings.Contains(a, "...") { |
| out = append(out, allPackagesInFS(a)...) |
| continue |
| } |
| if a == "all" || a == "std" || strings.Contains(a, "...") { |
| out = append(out, allPackages(a)...) |
| continue |
| } |
| out = append(out, a) |
| } |
| return out |
| } |
| |
| var atexitFuncs []func() |
| |
| func atexit(f func()) { |
| atexitFuncs = append(atexitFuncs, f) |
| } |
| |
| func exit() { |
| for _, f := range atexitFuncs { |
| f() |
| } |
| os.Exit(exitStatus) |
| } |
| |
| func fatalf(format string, args ...interface{}) { |
| errorf(format, args...) |
| exit() |
| } |
| |
| func errorf(format string, args ...interface{}) { |
| log.Printf(format, args...) |
| setExitStatus(1) |
| } |
| |
| var logf = log.Printf |
| |
| func exitIfErrors() { |
| if exitStatus != 0 { |
| exit() |
| } |
| } |
| |
| func run(cmdargs ...interface{}) { |
| cmdline := stringList(cmdargs...) |
| cmd := exec.Command(cmdline[0], cmdline[1:]...) |
| cmd.Stdout = os.Stdout |
| cmd.Stderr = os.Stderr |
| if err := cmd.Run(); err != nil { |
| errorf("%v", err) |
| } |
| } |
| |
| func runOut(dir string, cmdargs ...interface{}) []byte { |
| cmdline := stringList(cmdargs...) |
| cmd := exec.Command(cmdline[0], cmdline[1:]...) |
| cmd.Dir = dir |
| out, err := cmd.CombinedOutput() |
| if err != nil { |
| os.Stderr.Write(out) |
| errorf("%v", err) |
| out = nil |
| } |
| return out |
| } |
| |
| // matchPattern(pattern)(name) reports whether |
| // name matches pattern. Pattern is a limited glob |
| // pattern in which '...' means 'any string' and there |
| // is no other special syntax. |
| func matchPattern(pattern string) func(name string) bool { |
| re := regexp.QuoteMeta(pattern) |
| re = strings.Replace(re, `\.\.\.`, `.*`, -1) |
| reg := regexp.MustCompile(`^` + re + `$`) |
| return func(name string) bool { |
| return reg.MatchString(name) |
| } |
| } |
| |
| // allPackages returns all the packages that can be found |
| // under the $GOPATH directories and $GOROOT matching pattern. |
| // The pattern is either "all" (all packages), "std" (standard packages) |
| // or a path including "...". |
| func allPackages(pattern string) []string { |
| match := func(string) bool { return true } |
| if pattern != "all" && pattern != "std" { |
| match = matchPattern(pattern) |
| } |
| |
| have := map[string]bool{ |
| "builtin": true, // ignore pseudo-package that exists only for documentation |
| } |
| if !buildContext.CgoEnabled { |
| have["runtime/cgo"] = true // ignore during walk |
| } |
| var pkgs []string |
| |
| // Commands |
| goroot := build.Path[0].Path |
| cmd := filepath.Join(goroot, "src/cmd") + string(filepath.Separator) |
| filepath.Walk(cmd, func(path string, fi os.FileInfo, err error) error { |
| if err != nil || !fi.IsDir() || path == cmd { |
| return nil |
| } |
| name := path[len(cmd):] |
| // Commands are all in cmd/, not in subdirectories. |
| if strings.Contains(name, string(filepath.Separator)) { |
| return filepath.SkipDir |
| } |
| |
| _, err = build.ScanDir(path) |
| if err != nil { |
| return nil |
| } |
| |
| // We use, e.g., cmd/gofmt as the pseudo import path for gofmt. |
| name = "cmd/" + name |
| if !have[name] { |
| have[name] = true |
| if match(name) { |
| pkgs = append(pkgs, name) |
| } |
| } |
| return nil |
| }) |
| |
| for _, t := range build.Path { |
| if pattern == "std" && !t.Goroot { |
| continue |
| } |
| src := t.SrcDir() + string(filepath.Separator) |
| filepath.Walk(src, func(path string, fi os.FileInfo, err error) error { |
| if err != nil || !fi.IsDir() || path == src { |
| return nil |
| } |
| |
| // Avoid .foo, _foo, and testdata directory trees. |
| _, elem := filepath.Split(path) |
| if strings.HasPrefix(elem, ".") || strings.HasPrefix(elem, "_") || elem == "testdata" { |
| return filepath.SkipDir |
| } |
| |
| name := filepath.ToSlash(path[len(src):]) |
| if pattern == "std" && strings.Contains(name, ".") { |
| return filepath.SkipDir |
| } |
| if have[name] { |
| return nil |
| } |
| have[name] = true |
| |
| _, err = build.ScanDir(path) |
| if err != nil && strings.Contains(err.Error(), "no Go source files") { |
| return nil |
| } |
| |
| if match(name) { |
| pkgs = append(pkgs, name) |
| } |
| |
| // Avoid go/build test data. |
| // TODO: Move it into a testdata directory. |
| if path == filepath.Join(build.Path[0].SrcDir(), "go/build") { |
| return filepath.SkipDir |
| } |
| |
| return nil |
| }) |
| } |
| |
| if len(pkgs) == 0 { |
| fmt.Fprintf(os.Stderr, "warning: %q matched no packages\n", pattern) |
| } |
| return pkgs |
| } |
| |
| // allPackagesInFS is like allPackages but is passed a pattern |
| // beginning ./ or ../, meaning it should scan the tree rooted |
| // at the given directory. There are ... in the pattern too. |
| func allPackagesInFS(pattern string) []string { |
| // Find directory to begin the scan. |
| // Could be smarter but this one optimization |
| // is enough for now, since ... is usually at the |
| // end of a path. |
| i := strings.Index(pattern, "...") |
| dir, _ := path.Split(pattern[:i]) |
| |
| // pattern begins with ./ or ../. |
| // path.Clean will discard the ./ but not the ../. |
| // We need to preserve the ./ for pattern matching |
| // and in the returned import paths. |
| prefix := "" |
| if strings.HasPrefix(pattern, "./") { |
| prefix = "./" |
| } |
| match := matchPattern(pattern) |
| |
| var pkgs []string |
| filepath.Walk(dir, func(path string, fi os.FileInfo, err error) error { |
| if err != nil || !fi.IsDir() || path == dir { |
| return nil |
| } |
| |
| // Avoid .foo, _foo, and testdata directory trees. |
| _, elem := filepath.Split(path) |
| if strings.HasPrefix(elem, ".") || strings.HasPrefix(elem, "_") || elem == "testdata" { |
| return filepath.SkipDir |
| } |
| |
| name := prefix + filepath.ToSlash(path) |
| if !match(name) { |
| return nil |
| } |
| if _, err = build.ScanDir(path); err != nil { |
| return nil |
| } |
| pkgs = append(pkgs, name) |
| return nil |
| }) |
| |
| if len(pkgs) == 0 { |
| fmt.Fprintf(os.Stderr, "warning: %q matched no packages\n", pattern) |
| } |
| return pkgs |
| } |
| |
| // stringList's arguments should be a sequence of string or []string values. |
| // stringList flattens them into a single []string. |
| func stringList(args ...interface{}) []string { |
| var x []string |
| for _, arg := range args { |
| switch arg := arg.(type) { |
| case []string: |
| x = append(x, arg...) |
| case string: |
| x = append(x, arg) |
| default: |
| panic("stringList: invalid argument") |
| } |
| } |
| return x |
| } |
| |
| // isLocalPath returns true if arg is an import path denoting |
| // a local file system directory. That is, it returns true if the |
| // path begins with ./ or ../ . |
| func isLocalPath(arg string) bool { |
| return arg == "." || arg == ".." || strings.HasPrefix(arg, "./") || strings.HasPrefix(arg, "../") |
| } |