src/cmd/go/main.go - go - Git at Google

 // 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 {
 				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, "../")
 }
	// 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 {
	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, "../")
	}