Source file src/go/build/build.go

Documentation: go/build

		 1  // Copyright 2011 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package build
		 6  
		 7  import (
		 8  	"bytes"
		 9  	"errors"
		10  	"fmt"
		11  	"go/ast"
		12  	"go/build/constraint"
		13  	"go/doc"
		14  	"go/token"
		15  	"internal/buildcfg"
		16  	exec "internal/execabs"
		17  	"internal/goroot"
		18  	"internal/goversion"
		19  	"io"
		20  	"io/fs"
		21  	"io/ioutil"
		22  	"os"
		23  	pathpkg "path"
		24  	"path/filepath"
		25  	"runtime"
		26  	"sort"
		27  	"strconv"
		28  	"strings"
		29  	"unicode"
		30  	"unicode/utf8"
		31  )
		32  
		33  // A Context specifies the supporting context for a build.
		34  type Context struct {
		35  	GOARCH string // target architecture
		36  	GOOS	 string // target operating system
		37  	GOROOT string // Go root
		38  	GOPATH string // Go path
		39  
		40  	// Dir is the caller's working directory, or the empty string to use
		41  	// the current directory of the running process. In module mode, this is used
		42  	// to locate the main module.
		43  	//
		44  	// If Dir is non-empty, directories passed to Import and ImportDir must
		45  	// be absolute.
		46  	Dir string
		47  
		48  	CgoEnabled	bool	 // whether cgo files are included
		49  	UseAllFiles bool	 // use files regardless of +build lines, file names
		50  	Compiler		string // compiler to assume when computing target paths
		51  
		52  	// The build, tool, and release tags specify build constraints
		53  	// that should be considered satisfied when processing +build lines.
		54  	// Clients creating a new context may customize BuildTags, which
		55  	// defaults to empty, but it is usually an error to customize ToolTags or ReleaseTags.
		56  	// ToolTags defaults to build tags appropriate to the current Go toolchain configuration.
		57  	// ReleaseTags defaults to the list of Go releases the current release is compatible with.
		58  	// BuildTags is not set for the Default build Context.
		59  	// In addition to the BuildTags, ToolTags, and ReleaseTags, build constraints
		60  	// consider the values of GOARCH and GOOS as satisfied tags.
		61  	// The last element in ReleaseTags is assumed to be the current release.
		62  	BuildTags	 []string
		63  	ToolTags		[]string
		64  	ReleaseTags []string
		65  
		66  	// The install suffix specifies a suffix to use in the name of the installation
		67  	// directory. By default it is empty, but custom builds that need to keep
		68  	// their outputs separate can set InstallSuffix to do so. For example, when
		69  	// using the race detector, the go command uses InstallSuffix = "race", so
		70  	// that on a Linux/386 system, packages are written to a directory named
		71  	// "linux_386_race" instead of the usual "linux_386".
		72  	InstallSuffix string
		73  
		74  	// By default, Import uses the operating system's file system calls
		75  	// to read directories and files. To read from other sources,
		76  	// callers can set the following functions. They all have default
		77  	// behaviors that use the local file system, so clients need only set
		78  	// the functions whose behaviors they wish to change.
		79  
		80  	// JoinPath joins the sequence of path fragments into a single path.
		81  	// If JoinPath is nil, Import uses filepath.Join.
		82  	JoinPath func(elem ...string) string
		83  
		84  	// SplitPathList splits the path list into a slice of individual paths.
		85  	// If SplitPathList is nil, Import uses filepath.SplitList.
		86  	SplitPathList func(list string) []string
		87  
		88  	// IsAbsPath reports whether path is an absolute path.
		89  	// If IsAbsPath is nil, Import uses filepath.IsAbs.
		90  	IsAbsPath func(path string) bool
		91  
		92  	// IsDir reports whether the path names a directory.
		93  	// If IsDir is nil, Import calls os.Stat and uses the result's IsDir method.
		94  	IsDir func(path string) bool
		95  
		96  	// HasSubdir reports whether dir is lexically a subdirectory of
		97  	// root, perhaps multiple levels below. It does not try to check
		98  	// whether dir exists.
		99  	// If so, HasSubdir sets rel to a slash-separated path that
	 100  	// can be joined to root to produce a path equivalent to dir.
	 101  	// If HasSubdir is nil, Import uses an implementation built on
	 102  	// filepath.EvalSymlinks.
	 103  	HasSubdir func(root, dir string) (rel string, ok bool)
	 104  
	 105  	// ReadDir returns a slice of fs.FileInfo, sorted by Name,
	 106  	// describing the content of the named directory.
	 107  	// If ReadDir is nil, Import uses ioutil.ReadDir.
	 108  	ReadDir func(dir string) ([]fs.FileInfo, error)
	 109  
	 110  	// OpenFile opens a file (not a directory) for reading.
	 111  	// If OpenFile is nil, Import uses os.Open.
	 112  	OpenFile func(path string) (io.ReadCloser, error)
	 113  }
	 114  
	 115  // joinPath calls ctxt.JoinPath (if not nil) or else filepath.Join.
	 116  func (ctxt *Context) joinPath(elem ...string) string {
	 117  	if f := ctxt.JoinPath; f != nil {
	 118  		return f(elem...)
	 119  	}
	 120  	return filepath.Join(elem...)
	 121  }
	 122  
	 123  // splitPathList calls ctxt.SplitPathList (if not nil) or else filepath.SplitList.
	 124  func (ctxt *Context) splitPathList(s string) []string {
	 125  	if f := ctxt.SplitPathList; f != nil {
	 126  		return f(s)
	 127  	}
	 128  	return filepath.SplitList(s)
	 129  }
	 130  
	 131  // isAbsPath calls ctxt.IsAbsPath (if not nil) or else filepath.IsAbs.
	 132  func (ctxt *Context) isAbsPath(path string) bool {
	 133  	if f := ctxt.IsAbsPath; f != nil {
	 134  		return f(path)
	 135  	}
	 136  	return filepath.IsAbs(path)
	 137  }
	 138  
	 139  // isDir calls ctxt.IsDir (if not nil) or else uses os.Stat.
	 140  func (ctxt *Context) isDir(path string) bool {
	 141  	if f := ctxt.IsDir; f != nil {
	 142  		return f(path)
	 143  	}
	 144  	fi, err := os.Stat(path)
	 145  	return err == nil && fi.IsDir()
	 146  }
	 147  
	 148  // hasSubdir calls ctxt.HasSubdir (if not nil) or else uses
	 149  // the local file system to answer the question.
	 150  func (ctxt *Context) hasSubdir(root, dir string) (rel string, ok bool) {
	 151  	if f := ctxt.HasSubdir; f != nil {
	 152  		return f(root, dir)
	 153  	}
	 154  
	 155  	// Try using paths we received.
	 156  	if rel, ok = hasSubdir(root, dir); ok {
	 157  		return
	 158  	}
	 159  
	 160  	// Try expanding symlinks and comparing
	 161  	// expanded against unexpanded and
	 162  	// expanded against expanded.
	 163  	rootSym, _ := filepath.EvalSymlinks(root)
	 164  	dirSym, _ := filepath.EvalSymlinks(dir)
	 165  
	 166  	if rel, ok = hasSubdir(rootSym, dir); ok {
	 167  		return
	 168  	}
	 169  	if rel, ok = hasSubdir(root, dirSym); ok {
	 170  		return
	 171  	}
	 172  	return hasSubdir(rootSym, dirSym)
	 173  }
	 174  
	 175  // hasSubdir reports if dir is within root by performing lexical analysis only.
	 176  func hasSubdir(root, dir string) (rel string, ok bool) {
	 177  	const sep = string(filepath.Separator)
	 178  	root = filepath.Clean(root)
	 179  	if !strings.HasSuffix(root, sep) {
	 180  		root += sep
	 181  	}
	 182  	dir = filepath.Clean(dir)
	 183  	if !strings.HasPrefix(dir, root) {
	 184  		return "", false
	 185  	}
	 186  	return filepath.ToSlash(dir[len(root):]), true
	 187  }
	 188  
	 189  // readDir calls ctxt.ReadDir (if not nil) or else ioutil.ReadDir.
	 190  func (ctxt *Context) readDir(path string) ([]fs.FileInfo, error) {
	 191  	if f := ctxt.ReadDir; f != nil {
	 192  		return f(path)
	 193  	}
	 194  	// TODO: use os.ReadDir
	 195  	return ioutil.ReadDir(path)
	 196  }
	 197  
	 198  // openFile calls ctxt.OpenFile (if not nil) or else os.Open.
	 199  func (ctxt *Context) openFile(path string) (io.ReadCloser, error) {
	 200  	if fn := ctxt.OpenFile; fn != nil {
	 201  		return fn(path)
	 202  	}
	 203  
	 204  	f, err := os.Open(path)
	 205  	if err != nil {
	 206  		return nil, err // nil interface
	 207  	}
	 208  	return f, nil
	 209  }
	 210  
	 211  // isFile determines whether path is a file by trying to open it.
	 212  // It reuses openFile instead of adding another function to the
	 213  // list in Context.
	 214  func (ctxt *Context) isFile(path string) bool {
	 215  	f, err := ctxt.openFile(path)
	 216  	if err != nil {
	 217  		return false
	 218  	}
	 219  	f.Close()
	 220  	return true
	 221  }
	 222  
	 223  // gopath returns the list of Go path directories.
	 224  func (ctxt *Context) gopath() []string {
	 225  	var all []string
	 226  	for _, p := range ctxt.splitPathList(ctxt.GOPATH) {
	 227  		if p == "" || p == ctxt.GOROOT {
	 228  			// Empty paths are uninteresting.
	 229  			// If the path is the GOROOT, ignore it.
	 230  			// People sometimes set GOPATH=$GOROOT.
	 231  			// Do not get confused by this common mistake.
	 232  			continue
	 233  		}
	 234  		if strings.HasPrefix(p, "~") {
	 235  			// Path segments starting with ~ on Unix are almost always
	 236  			// users who have incorrectly quoted ~ while setting GOPATH,
	 237  			// preventing it from expanding to $HOME.
	 238  			// The situation is made more confusing by the fact that
	 239  			// bash allows quoted ~ in $PATH (most shells do not).
	 240  			// Do not get confused by this, and do not try to use the path.
	 241  			// It does not exist, and printing errors about it confuses
	 242  			// those users even more, because they think "sure ~ exists!".
	 243  			// The go command diagnoses this situation and prints a
	 244  			// useful error.
	 245  			// On Windows, ~ is used in short names, such as c:\progra~1
	 246  			// for c:\program files.
	 247  			continue
	 248  		}
	 249  		all = append(all, p)
	 250  	}
	 251  	return all
	 252  }
	 253  
	 254  // SrcDirs returns a list of package source root directories.
	 255  // It draws from the current Go root and Go path but omits directories
	 256  // that do not exist.
	 257  func (ctxt *Context) SrcDirs() []string {
	 258  	var all []string
	 259  	if ctxt.GOROOT != "" && ctxt.Compiler != "gccgo" {
	 260  		dir := ctxt.joinPath(ctxt.GOROOT, "src")
	 261  		if ctxt.isDir(dir) {
	 262  			all = append(all, dir)
	 263  		}
	 264  	}
	 265  	for _, p := range ctxt.gopath() {
	 266  		dir := ctxt.joinPath(p, "src")
	 267  		if ctxt.isDir(dir) {
	 268  			all = append(all, dir)
	 269  		}
	 270  	}
	 271  	return all
	 272  }
	 273  
	 274  // Default is the default Context for builds.
	 275  // It uses the GOARCH, GOOS, GOROOT, and GOPATH environment variables
	 276  // if set, or else the compiled code's GOARCH, GOOS, and GOROOT.
	 277  var Default Context = defaultContext()
	 278  
	 279  func defaultGOPATH() string {
	 280  	env := "HOME"
	 281  	if runtime.GOOS == "windows" {
	 282  		env = "USERPROFILE"
	 283  	} else if runtime.GOOS == "plan9" {
	 284  		env = "home"
	 285  	}
	 286  	if home := os.Getenv(env); home != "" {
	 287  		def := filepath.Join(home, "go")
	 288  		if filepath.Clean(def) == filepath.Clean(runtime.GOROOT()) {
	 289  			// Don't set the default GOPATH to GOROOT,
	 290  			// as that will trigger warnings from the go tool.
	 291  			return ""
	 292  		}
	 293  		return def
	 294  	}
	 295  	return ""
	 296  }
	 297  
	 298  var defaultToolTags, defaultReleaseTags []string
	 299  
	 300  func defaultContext() Context {
	 301  	var c Context
	 302  
	 303  	c.GOARCH = buildcfg.GOARCH
	 304  	c.GOOS = buildcfg.GOOS
	 305  	c.GOROOT = pathpkg.Clean(runtime.GOROOT())
	 306  	c.GOPATH = envOr("GOPATH", defaultGOPATH())
	 307  	c.Compiler = runtime.Compiler
	 308  
	 309  	// For each experiment that has been enabled in the toolchain, define a
	 310  	// build tag with the same name but prefixed by "goexperiment." which can be
	 311  	// used for compiling alternative files for the experiment. This allows
	 312  	// changes for the experiment, like extra struct fields in the runtime,
	 313  	// without affecting the base non-experiment code at all.
	 314  	for _, exp := range buildcfg.EnabledExperiments() {
	 315  		c.ToolTags = append(c.ToolTags, "goexperiment."+exp)
	 316  	}
	 317  	defaultToolTags = append([]string{}, c.ToolTags...) // our own private copy
	 318  
	 319  	// Each major Go release in the Go 1.x series adds a new
	 320  	// "go1.x" release tag. That is, the go1.x tag is present in
	 321  	// all releases >= Go 1.x. Code that requires Go 1.x or later
	 322  	// should say "+build go1.x", and code that should only be
	 323  	// built before Go 1.x (perhaps it is the stub to use in that
	 324  	// case) should say "+build !go1.x".
	 325  	// The last element in ReleaseTags is the current release.
	 326  	for i := 1; i <= goversion.Version; i++ {
	 327  		c.ReleaseTags = append(c.ReleaseTags, "go1."+strconv.Itoa(i))
	 328  	}
	 329  
	 330  	defaultReleaseTags = append([]string{}, c.ReleaseTags...) // our own private copy
	 331  
	 332  	env := os.Getenv("CGO_ENABLED")
	 333  	if env == "" {
	 334  		env = defaultCGO_ENABLED
	 335  	}
	 336  	switch env {
	 337  	case "1":
	 338  		c.CgoEnabled = true
	 339  	case "0":
	 340  		c.CgoEnabled = false
	 341  	default:
	 342  		// cgo must be explicitly enabled for cross compilation builds
	 343  		if runtime.GOARCH == c.GOARCH && runtime.GOOS == c.GOOS {
	 344  			c.CgoEnabled = cgoEnabled[c.GOOS+"/"+c.GOARCH]
	 345  			break
	 346  		}
	 347  		c.CgoEnabled = false
	 348  	}
	 349  
	 350  	return c
	 351  }
	 352  
	 353  func envOr(name, def string) string {
	 354  	s := os.Getenv(name)
	 355  	if s == "" {
	 356  		return def
	 357  	}
	 358  	return s
	 359  }
	 360  
	 361  // An ImportMode controls the behavior of the Import method.
	 362  type ImportMode uint
	 363  
	 364  const (
	 365  	// If FindOnly is set, Import stops after locating the directory
	 366  	// that should contain the sources for a package. It does not
	 367  	// read any files in the directory.
	 368  	FindOnly ImportMode = 1 << iota
	 369  
	 370  	// If AllowBinary is set, Import can be satisfied by a compiled
	 371  	// package object without corresponding sources.
	 372  	//
	 373  	// Deprecated:
	 374  	// The supported way to create a compiled-only package is to
	 375  	// write source code containing a //go:binary-only-package comment at
	 376  	// the top of the file. Such a package will be recognized
	 377  	// regardless of this flag setting (because it has source code)
	 378  	// and will have BinaryOnly set to true in the returned Package.
	 379  	AllowBinary
	 380  
	 381  	// If ImportComment is set, parse import comments on package statements.
	 382  	// Import returns an error if it finds a comment it cannot understand
	 383  	// or finds conflicting comments in multiple source files.
	 384  	// See golang.org/s/go14customimport for more information.
	 385  	ImportComment
	 386  
	 387  	// By default, Import searches vendor directories
	 388  	// that apply in the given source directory before searching
	 389  	// the GOROOT and GOPATH roots.
	 390  	// If an Import finds and returns a package using a vendor
	 391  	// directory, the resulting ImportPath is the complete path
	 392  	// to the package, including the path elements leading up
	 393  	// to and including "vendor".
	 394  	// For example, if Import("y", "x/subdir", 0) finds
	 395  	// "x/vendor/y", the returned package's ImportPath is "x/vendor/y",
	 396  	// not plain "y".
	 397  	// See golang.org/s/go15vendor for more information.
	 398  	//
	 399  	// Setting IgnoreVendor ignores vendor directories.
	 400  	//
	 401  	// In contrast to the package's ImportPath,
	 402  	// the returned package's Imports, TestImports, and XTestImports
	 403  	// are always the exact import paths from the source files:
	 404  	// Import makes no attempt to resolve or check those paths.
	 405  	IgnoreVendor
	 406  )
	 407  
	 408  // A Package describes the Go package found in a directory.
	 409  type Package struct {
	 410  	Dir					 string	 // directory containing package sources
	 411  	Name					string	 // package name
	 412  	ImportComment string	 // path in import comment on package statement
	 413  	Doc					 string	 // documentation synopsis
	 414  	ImportPath		string	 // import path of package ("" if unknown)
	 415  	Root					string	 // root of Go tree where this package lives
	 416  	SrcRoot			 string	 // package source root directory ("" if unknown)
	 417  	PkgRoot			 string	 // package install root directory ("" if unknown)
	 418  	PkgTargetRoot string	 // architecture dependent install root directory ("" if unknown)
	 419  	BinDir				string	 // command install directory ("" if unknown)
	 420  	Goroot				bool		 // package found in Go root
	 421  	PkgObj				string	 // installed .a file
	 422  	AllTags			 []string // tags that can influence file selection in this directory
	 423  	ConflictDir	 string	 // this directory shadows Dir in $GOPATH
	 424  	BinaryOnly		bool		 // cannot be rebuilt from source (has //go:binary-only-package comment)
	 425  
	 426  	// Source files
	 427  	GoFiles					 []string // .go source files (excluding CgoFiles, TestGoFiles, XTestGoFiles)
	 428  	CgoFiles					[]string // .go source files that import "C"
	 429  	IgnoredGoFiles		[]string // .go source files ignored for this build (including ignored _test.go files)
	 430  	InvalidGoFiles		[]string // .go source files with detected problems (parse error, wrong package name, and so on)
	 431  	IgnoredOtherFiles []string // non-.go source files ignored for this build
	 432  	CFiles						[]string // .c source files
	 433  	CXXFiles					[]string // .cc, .cpp and .cxx source files
	 434  	MFiles						[]string // .m (Objective-C) source files
	 435  	HFiles						[]string // .h, .hh, .hpp and .hxx source files
	 436  	FFiles						[]string // .f, .F, .for and .f90 Fortran source files
	 437  	SFiles						[]string // .s source files
	 438  	SwigFiles				 []string // .swig files
	 439  	SwigCXXFiles			[]string // .swigcxx files
	 440  	SysoFiles				 []string // .syso system object files to add to archive
	 441  
	 442  	// Cgo directives
	 443  	CgoCFLAGS		[]string // Cgo CFLAGS directives
	 444  	CgoCPPFLAGS	[]string // Cgo CPPFLAGS directives
	 445  	CgoCXXFLAGS	[]string // Cgo CXXFLAGS directives
	 446  	CgoFFLAGS		[]string // Cgo FFLAGS directives
	 447  	CgoLDFLAGS	 []string // Cgo LDFLAGS directives
	 448  	CgoPkgConfig []string // Cgo pkg-config directives
	 449  
	 450  	// Test information
	 451  	TestGoFiles	[]string // _test.go files in package
	 452  	XTestGoFiles []string // _test.go files outside package
	 453  
	 454  	// Dependency information
	 455  	Imports				[]string										// import paths from GoFiles, CgoFiles
	 456  	ImportPos			map[string][]token.Position // line information for Imports
	 457  	TestImports		[]string										// import paths from TestGoFiles
	 458  	TestImportPos	map[string][]token.Position // line information for TestImports
	 459  	XTestImports	 []string										// import paths from XTestGoFiles
	 460  	XTestImportPos map[string][]token.Position // line information for XTestImports
	 461  
	 462  	// //go:embed patterns found in Go source files
	 463  	// For example, if a source file says
	 464  	//	//go:embed a* b.c
	 465  	// then the list will contain those two strings as separate entries.
	 466  	// (See package embed for more details about //go:embed.)
	 467  	EmbedPatterns				[]string										// patterns from GoFiles, CgoFiles
	 468  	EmbedPatternPos			map[string][]token.Position // line information for EmbedPatterns
	 469  	TestEmbedPatterns		[]string										// patterns from TestGoFiles
	 470  	TestEmbedPatternPos	map[string][]token.Position // line information for TestEmbedPatterns
	 471  	XTestEmbedPatterns	 []string										// patterns from XTestGoFiles
	 472  	XTestEmbedPatternPos map[string][]token.Position // line information for XTestEmbedPatternPos
	 473  }
	 474  
	 475  // IsCommand reports whether the package is considered a
	 476  // command to be installed (not just a library).
	 477  // Packages named "main" are treated as commands.
	 478  func (p *Package) IsCommand() bool {
	 479  	return p.Name == "main"
	 480  }
	 481  
	 482  // ImportDir is like Import but processes the Go package found in
	 483  // the named directory.
	 484  func (ctxt *Context) ImportDir(dir string, mode ImportMode) (*Package, error) {
	 485  	return ctxt.Import(".", dir, mode)
	 486  }
	 487  
	 488  // NoGoError is the error used by Import to describe a directory
	 489  // containing no buildable Go source files. (It may still contain
	 490  // test files, files hidden by build tags, and so on.)
	 491  type NoGoError struct {
	 492  	Dir string
	 493  }
	 494  
	 495  func (e *NoGoError) Error() string {
	 496  	return "no buildable Go source files in " + e.Dir
	 497  }
	 498  
	 499  // MultiplePackageError describes a directory containing
	 500  // multiple buildable Go source files for multiple packages.
	 501  type MultiplePackageError struct {
	 502  	Dir			string	 // directory containing files
	 503  	Packages []string // package names found
	 504  	Files		[]string // corresponding files: Files[i] declares package Packages[i]
	 505  }
	 506  
	 507  func (e *MultiplePackageError) Error() string {
	 508  	// Error string limited to two entries for compatibility.
	 509  	return fmt.Sprintf("found packages %s (%s) and %s (%s) in %s", e.Packages[0], e.Files[0], e.Packages[1], e.Files[1], e.Dir)
	 510  }
	 511  
	 512  func nameExt(name string) string {
	 513  	i := strings.LastIndex(name, ".")
	 514  	if i < 0 {
	 515  		return ""
	 516  	}
	 517  	return name[i:]
	 518  }
	 519  
	 520  // Import returns details about the Go package named by the import path,
	 521  // interpreting local import paths relative to the srcDir directory.
	 522  // If the path is a local import path naming a package that can be imported
	 523  // using a standard import path, the returned package will set p.ImportPath
	 524  // to that path.
	 525  //
	 526  // In the directory containing the package, .go, .c, .h, and .s files are
	 527  // considered part of the package except for:
	 528  //
	 529  //	- .go files in package documentation
	 530  //	- files starting with _ or . (likely editor temporary files)
	 531  //	- files with build constraints not satisfied by the context
	 532  //
	 533  // If an error occurs, Import returns a non-nil error and a non-nil
	 534  // *Package containing partial information.
	 535  //
	 536  func (ctxt *Context) Import(path string, srcDir string, mode ImportMode) (*Package, error) {
	 537  	p := &Package{
	 538  		ImportPath: path,
	 539  	}
	 540  	if path == "" {
	 541  		return p, fmt.Errorf("import %q: invalid import path", path)
	 542  	}
	 543  
	 544  	var pkgtargetroot string
	 545  	var pkga string
	 546  	var pkgerr error
	 547  	suffix := ""
	 548  	if ctxt.InstallSuffix != "" {
	 549  		suffix = "_" + ctxt.InstallSuffix
	 550  	}
	 551  	switch ctxt.Compiler {
	 552  	case "gccgo":
	 553  		pkgtargetroot = "pkg/gccgo_" + ctxt.GOOS + "_" + ctxt.GOARCH + suffix
	 554  	case "gc":
	 555  		pkgtargetroot = "pkg/" + ctxt.GOOS + "_" + ctxt.GOARCH + suffix
	 556  	default:
	 557  		// Save error for end of function.
	 558  		pkgerr = fmt.Errorf("import %q: unknown compiler %q", path, ctxt.Compiler)
	 559  	}
	 560  	setPkga := func() {
	 561  		switch ctxt.Compiler {
	 562  		case "gccgo":
	 563  			dir, elem := pathpkg.Split(p.ImportPath)
	 564  			pkga = pkgtargetroot + "/" + dir + "lib" + elem + ".a"
	 565  		case "gc":
	 566  			pkga = pkgtargetroot + "/" + p.ImportPath + ".a"
	 567  		}
	 568  	}
	 569  	setPkga()
	 570  
	 571  	binaryOnly := false
	 572  	if IsLocalImport(path) {
	 573  		pkga = "" // local imports have no installed path
	 574  		if srcDir == "" {
	 575  			return p, fmt.Errorf("import %q: import relative to unknown directory", path)
	 576  		}
	 577  		if !ctxt.isAbsPath(path) {
	 578  			p.Dir = ctxt.joinPath(srcDir, path)
	 579  		}
	 580  		// p.Dir directory may or may not exist. Gather partial information first, check if it exists later.
	 581  		// Determine canonical import path, if any.
	 582  		// Exclude results where the import path would include /testdata/.
	 583  		inTestdata := func(sub string) bool {
	 584  			return strings.Contains(sub, "/testdata/") || strings.HasSuffix(sub, "/testdata") || strings.HasPrefix(sub, "testdata/") || sub == "testdata"
	 585  		}
	 586  		if ctxt.GOROOT != "" {
	 587  			root := ctxt.joinPath(ctxt.GOROOT, "src")
	 588  			if sub, ok := ctxt.hasSubdir(root, p.Dir); ok && !inTestdata(sub) {
	 589  				p.Goroot = true
	 590  				p.ImportPath = sub
	 591  				p.Root = ctxt.GOROOT
	 592  				setPkga() // p.ImportPath changed
	 593  				goto Found
	 594  			}
	 595  		}
	 596  		all := ctxt.gopath()
	 597  		for i, root := range all {
	 598  			rootsrc := ctxt.joinPath(root, "src")
	 599  			if sub, ok := ctxt.hasSubdir(rootsrc, p.Dir); ok && !inTestdata(sub) {
	 600  				// We found a potential import path for dir,
	 601  				// but check that using it wouldn't find something
	 602  				// else first.
	 603  				if ctxt.GOROOT != "" && ctxt.Compiler != "gccgo" {
	 604  					if dir := ctxt.joinPath(ctxt.GOROOT, "src", sub); ctxt.isDir(dir) {
	 605  						p.ConflictDir = dir
	 606  						goto Found
	 607  					}
	 608  				}
	 609  				for _, earlyRoot := range all[:i] {
	 610  					if dir := ctxt.joinPath(earlyRoot, "src", sub); ctxt.isDir(dir) {
	 611  						p.ConflictDir = dir
	 612  						goto Found
	 613  					}
	 614  				}
	 615  
	 616  				// sub would not name some other directory instead of this one.
	 617  				// Record it.
	 618  				p.ImportPath = sub
	 619  				p.Root = root
	 620  				setPkga() // p.ImportPath changed
	 621  				goto Found
	 622  			}
	 623  		}
	 624  		// It's okay that we didn't find a root containing dir.
	 625  		// Keep going with the information we have.
	 626  	} else {
	 627  		if strings.HasPrefix(path, "/") {
	 628  			return p, fmt.Errorf("import %q: cannot import absolute path", path)
	 629  		}
	 630  
	 631  		if err := ctxt.importGo(p, path, srcDir, mode); err == nil {
	 632  			goto Found
	 633  		} else if err != errNoModules {
	 634  			return p, err
	 635  		}
	 636  
	 637  		gopath := ctxt.gopath() // needed twice below; avoid computing many times
	 638  
	 639  		// tried records the location of unsuccessful package lookups
	 640  		var tried struct {
	 641  			vendor []string
	 642  			goroot string
	 643  			gopath []string
	 644  		}
	 645  
	 646  		// Vendor directories get first chance to satisfy import.
	 647  		if mode&IgnoreVendor == 0 && srcDir != "" {
	 648  			searchVendor := func(root string, isGoroot bool) bool {
	 649  				sub, ok := ctxt.hasSubdir(root, srcDir)
	 650  				if !ok || !strings.HasPrefix(sub, "src/") || strings.Contains(sub, "/testdata/") {
	 651  					return false
	 652  				}
	 653  				for {
	 654  					vendor := ctxt.joinPath(root, sub, "vendor")
	 655  					if ctxt.isDir(vendor) {
	 656  						dir := ctxt.joinPath(vendor, path)
	 657  						if ctxt.isDir(dir) && hasGoFiles(ctxt, dir) {
	 658  							p.Dir = dir
	 659  							p.ImportPath = strings.TrimPrefix(pathpkg.Join(sub, "vendor", path), "src/")
	 660  							p.Goroot = isGoroot
	 661  							p.Root = root
	 662  							setPkga() // p.ImportPath changed
	 663  							return true
	 664  						}
	 665  						tried.vendor = append(tried.vendor, dir)
	 666  					}
	 667  					i := strings.LastIndex(sub, "/")
	 668  					if i < 0 {
	 669  						break
	 670  					}
	 671  					sub = sub[:i]
	 672  				}
	 673  				return false
	 674  			}
	 675  			if ctxt.Compiler != "gccgo" && searchVendor(ctxt.GOROOT, true) {
	 676  				goto Found
	 677  			}
	 678  			for _, root := range gopath {
	 679  				if searchVendor(root, false) {
	 680  					goto Found
	 681  				}
	 682  			}
	 683  		}
	 684  
	 685  		// Determine directory from import path.
	 686  		if ctxt.GOROOT != "" {
	 687  			// If the package path starts with "vendor/", only search GOROOT before
	 688  			// GOPATH if the importer is also within GOROOT. That way, if the user has
	 689  			// vendored in a package that is subsequently included in the standard
	 690  			// distribution, they'll continue to pick up their own vendored copy.
	 691  			gorootFirst := srcDir == "" || !strings.HasPrefix(path, "vendor/")
	 692  			if !gorootFirst {
	 693  				_, gorootFirst = ctxt.hasSubdir(ctxt.GOROOT, srcDir)
	 694  			}
	 695  			if gorootFirst {
	 696  				dir := ctxt.joinPath(ctxt.GOROOT, "src", path)
	 697  				if ctxt.Compiler != "gccgo" {
	 698  					isDir := ctxt.isDir(dir)
	 699  					binaryOnly = !isDir && mode&AllowBinary != 0 && pkga != "" && ctxt.isFile(ctxt.joinPath(ctxt.GOROOT, pkga))
	 700  					if isDir || binaryOnly {
	 701  						p.Dir = dir
	 702  						p.Goroot = true
	 703  						p.Root = ctxt.GOROOT
	 704  						goto Found
	 705  					}
	 706  				}
	 707  				tried.goroot = dir
	 708  			}
	 709  		}
	 710  		if ctxt.Compiler == "gccgo" && goroot.IsStandardPackage(ctxt.GOROOT, ctxt.Compiler, path) {
	 711  			p.Dir = ctxt.joinPath(ctxt.GOROOT, "src", path)
	 712  			p.Goroot = true
	 713  			p.Root = ctxt.GOROOT
	 714  			goto Found
	 715  		}
	 716  		for _, root := range gopath {
	 717  			dir := ctxt.joinPath(root, "src", path)
	 718  			isDir := ctxt.isDir(dir)
	 719  			binaryOnly = !isDir && mode&AllowBinary != 0 && pkga != "" && ctxt.isFile(ctxt.joinPath(root, pkga))
	 720  			if isDir || binaryOnly {
	 721  				p.Dir = dir
	 722  				p.Root = root
	 723  				goto Found
	 724  			}
	 725  			tried.gopath = append(tried.gopath, dir)
	 726  		}
	 727  
	 728  		// If we tried GOPATH first due to a "vendor/" prefix, fall back to GOPATH.
	 729  		// That way, the user can still get useful results from 'go list' for
	 730  		// standard-vendored paths passed on the command line.
	 731  		if ctxt.GOROOT != "" && tried.goroot == "" {
	 732  			dir := ctxt.joinPath(ctxt.GOROOT, "src", path)
	 733  			if ctxt.Compiler != "gccgo" {
	 734  				isDir := ctxt.isDir(dir)
	 735  				binaryOnly = !isDir && mode&AllowBinary != 0 && pkga != "" && ctxt.isFile(ctxt.joinPath(ctxt.GOROOT, pkga))
	 736  				if isDir || binaryOnly {
	 737  					p.Dir = dir
	 738  					p.Goroot = true
	 739  					p.Root = ctxt.GOROOT
	 740  					goto Found
	 741  				}
	 742  			}
	 743  			tried.goroot = dir
	 744  		}
	 745  
	 746  		// package was not found
	 747  		var paths []string
	 748  		format := "\t%s (vendor tree)"
	 749  		for _, dir := range tried.vendor {
	 750  			paths = append(paths, fmt.Sprintf(format, dir))
	 751  			format = "\t%s"
	 752  		}
	 753  		if tried.goroot != "" {
	 754  			paths = append(paths, fmt.Sprintf("\t%s (from $GOROOT)", tried.goroot))
	 755  		} else {
	 756  			paths = append(paths, "\t($GOROOT not set)")
	 757  		}
	 758  		format = "\t%s (from $GOPATH)"
	 759  		for _, dir := range tried.gopath {
	 760  			paths = append(paths, fmt.Sprintf(format, dir))
	 761  			format = "\t%s"
	 762  		}
	 763  		if len(tried.gopath) == 0 {
	 764  			paths = append(paths, "\t($GOPATH not set. For more details see: 'go help gopath')")
	 765  		}
	 766  		return p, fmt.Errorf("cannot find package %q in any of:\n%s", path, strings.Join(paths, "\n"))
	 767  	}
	 768  
	 769  Found:
	 770  	if p.Root != "" {
	 771  		p.SrcRoot = ctxt.joinPath(p.Root, "src")
	 772  		p.PkgRoot = ctxt.joinPath(p.Root, "pkg")
	 773  		p.BinDir = ctxt.joinPath(p.Root, "bin")
	 774  		if pkga != "" {
	 775  			p.PkgTargetRoot = ctxt.joinPath(p.Root, pkgtargetroot)
	 776  			p.PkgObj = ctxt.joinPath(p.Root, pkga)
	 777  		}
	 778  	}
	 779  
	 780  	// If it's a local import path, by the time we get here, we still haven't checked
	 781  	// that p.Dir directory exists. This is the right time to do that check.
	 782  	// We can't do it earlier, because we want to gather partial information for the
	 783  	// non-nil *Package returned when an error occurs.
	 784  	// We need to do this before we return early on FindOnly flag.
	 785  	if IsLocalImport(path) && !ctxt.isDir(p.Dir) {
	 786  		if ctxt.Compiler == "gccgo" && p.Goroot {
	 787  			// gccgo has no sources for GOROOT packages.
	 788  			return p, nil
	 789  		}
	 790  
	 791  		// package was not found
	 792  		return p, fmt.Errorf("cannot find package %q in:\n\t%s", path, p.Dir)
	 793  	}
	 794  
	 795  	if mode&FindOnly != 0 {
	 796  		return p, pkgerr
	 797  	}
	 798  	if binaryOnly && (mode&AllowBinary) != 0 {
	 799  		return p, pkgerr
	 800  	}
	 801  
	 802  	if ctxt.Compiler == "gccgo" && p.Goroot {
	 803  		// gccgo has no sources for GOROOT packages.
	 804  		return p, nil
	 805  	}
	 806  
	 807  	dirs, err := ctxt.readDir(p.Dir)
	 808  	if err != nil {
	 809  		return p, err
	 810  	}
	 811  
	 812  	var badGoError error
	 813  	badFiles := make(map[string]bool)
	 814  	badFile := func(name string, err error) {
	 815  		if badGoError == nil {
	 816  			badGoError = err
	 817  		}
	 818  		if !badFiles[name] {
	 819  			p.InvalidGoFiles = append(p.InvalidGoFiles, name)
	 820  			badFiles[name] = true
	 821  		}
	 822  	}
	 823  
	 824  	var Sfiles []string // files with ".S"(capital S)/.sx(capital s equivalent for case insensitive filesystems)
	 825  	var firstFile, firstCommentFile string
	 826  	embedPos := make(map[string][]token.Position)
	 827  	testEmbedPos := make(map[string][]token.Position)
	 828  	xTestEmbedPos := make(map[string][]token.Position)
	 829  	importPos := make(map[string][]token.Position)
	 830  	testImportPos := make(map[string][]token.Position)
	 831  	xTestImportPos := make(map[string][]token.Position)
	 832  	allTags := make(map[string]bool)
	 833  	fset := token.NewFileSet()
	 834  	for _, d := range dirs {
	 835  		if d.IsDir() {
	 836  			continue
	 837  		}
	 838  		if d.Mode()&fs.ModeSymlink != 0 {
	 839  			if ctxt.isDir(ctxt.joinPath(p.Dir, d.Name())) {
	 840  				// Symlinks to directories are not source files.
	 841  				continue
	 842  			}
	 843  		}
	 844  
	 845  		name := d.Name()
	 846  		ext := nameExt(name)
	 847  
	 848  		info, err := ctxt.matchFile(p.Dir, name, allTags, &p.BinaryOnly, fset)
	 849  		if err != nil {
	 850  			badFile(name, err)
	 851  			continue
	 852  		}
	 853  		if info == nil {
	 854  			if strings.HasPrefix(name, "_") || strings.HasPrefix(name, ".") {
	 855  				// not due to build constraints - don't report
	 856  			} else if ext == ".go" {
	 857  				p.IgnoredGoFiles = append(p.IgnoredGoFiles, name)
	 858  			} else if fileListForExt(p, ext) != nil {
	 859  				p.IgnoredOtherFiles = append(p.IgnoredOtherFiles, name)
	 860  			}
	 861  			continue
	 862  		}
	 863  		data, filename := info.header, info.name
	 864  
	 865  		// Going to save the file. For non-Go files, can stop here.
	 866  		switch ext {
	 867  		case ".go":
	 868  			// keep going
	 869  		case ".S", ".sx":
	 870  			// special case for cgo, handled at end
	 871  			Sfiles = append(Sfiles, name)
	 872  			continue
	 873  		default:
	 874  			if list := fileListForExt(p, ext); list != nil {
	 875  				*list = append(*list, name)
	 876  			}
	 877  			continue
	 878  		}
	 879  
	 880  		if info.parseErr != nil {
	 881  			badFile(name, info.parseErr)
	 882  			// Fall through: we might still have a partial AST in info.parsed,
	 883  			// and we want to list files with parse errors anyway.
	 884  		}
	 885  
	 886  		var pkg string
	 887  		if info.parsed != nil {
	 888  			pkg = info.parsed.Name.Name
	 889  			if pkg == "documentation" {
	 890  				p.IgnoredGoFiles = append(p.IgnoredGoFiles, name)
	 891  				continue
	 892  			}
	 893  		}
	 894  
	 895  		isTest := strings.HasSuffix(name, "_test.go")
	 896  		isXTest := false
	 897  		if isTest && strings.HasSuffix(pkg, "_test") {
	 898  			isXTest = true
	 899  			pkg = pkg[:len(pkg)-len("_test")]
	 900  		}
	 901  
	 902  		if p.Name == "" {
	 903  			p.Name = pkg
	 904  			firstFile = name
	 905  		} else if pkg != p.Name {
	 906  			// TODO(#45999): The choice of p.Name is arbitrary based on file iteration
	 907  			// order. Instead of resolving p.Name arbitrarily, we should clear out the
	 908  			// existing name and mark the existing files as also invalid.
	 909  			badFile(name, &MultiplePackageError{
	 910  				Dir:			p.Dir,
	 911  				Packages: []string{p.Name, pkg},
	 912  				Files:		[]string{firstFile, name},
	 913  			})
	 914  		}
	 915  		// Grab the first package comment as docs, provided it is not from a test file.
	 916  		if info.parsed != nil && info.parsed.Doc != nil && p.Doc == "" && !isTest && !isXTest {
	 917  			p.Doc = doc.Synopsis(info.parsed.Doc.Text())
	 918  		}
	 919  
	 920  		if mode&ImportComment != 0 {
	 921  			qcom, line := findImportComment(data)
	 922  			if line != 0 {
	 923  				com, err := strconv.Unquote(qcom)
	 924  				if err != nil {
	 925  					badFile(name, fmt.Errorf("%s:%d: cannot parse import comment", filename, line))
	 926  				} else if p.ImportComment == "" {
	 927  					p.ImportComment = com
	 928  					firstCommentFile = name
	 929  				} else if p.ImportComment != com {
	 930  					badFile(name, fmt.Errorf("found import comments %q (%s) and %q (%s) in %s", p.ImportComment, firstCommentFile, com, name, p.Dir))
	 931  				}
	 932  			}
	 933  		}
	 934  
	 935  		// Record imports and information about cgo.
	 936  		isCgo := false
	 937  		for _, imp := range info.imports {
	 938  			if imp.path == "C" {
	 939  				if isTest {
	 940  					badFile(name, fmt.Errorf("use of cgo in test %s not supported", filename))
	 941  					continue
	 942  				}
	 943  				isCgo = true
	 944  				if imp.doc != nil {
	 945  					if err := ctxt.saveCgo(filename, p, imp.doc); err != nil {
	 946  						badFile(name, err)
	 947  					}
	 948  				}
	 949  			}
	 950  		}
	 951  
	 952  		var fileList *[]string
	 953  		var importMap, embedMap map[string][]token.Position
	 954  		switch {
	 955  		case isCgo:
	 956  			allTags["cgo"] = true
	 957  			if ctxt.CgoEnabled {
	 958  				fileList = &p.CgoFiles
	 959  				importMap = importPos
	 960  				embedMap = embedPos
	 961  			} else {
	 962  				// Ignore imports and embeds from cgo files if cgo is disabled.
	 963  				fileList = &p.IgnoredGoFiles
	 964  			}
	 965  		case isXTest:
	 966  			fileList = &p.XTestGoFiles
	 967  			importMap = xTestImportPos
	 968  			embedMap = xTestEmbedPos
	 969  		case isTest:
	 970  			fileList = &p.TestGoFiles
	 971  			importMap = testImportPos
	 972  			embedMap = testEmbedPos
	 973  		default:
	 974  			fileList = &p.GoFiles
	 975  			importMap = importPos
	 976  			embedMap = embedPos
	 977  		}
	 978  		*fileList = append(*fileList, name)
	 979  		if importMap != nil {
	 980  			for _, imp := range info.imports {
	 981  				importMap[imp.path] = append(importMap[imp.path], fset.Position(imp.pos))
	 982  			}
	 983  		}
	 984  		if embedMap != nil {
	 985  			for _, emb := range info.embeds {
	 986  				embedMap[emb.pattern] = append(embedMap[emb.pattern], emb.pos)
	 987  			}
	 988  		}
	 989  	}
	 990  
	 991  	for tag := range allTags {
	 992  		p.AllTags = append(p.AllTags, tag)
	 993  	}
	 994  	sort.Strings(p.AllTags)
	 995  
	 996  	p.EmbedPatterns, p.EmbedPatternPos = cleanDecls(embedPos)
	 997  	p.TestEmbedPatterns, p.TestEmbedPatternPos = cleanDecls(testEmbedPos)
	 998  	p.XTestEmbedPatterns, p.XTestEmbedPatternPos = cleanDecls(xTestEmbedPos)
	 999  
	1000  	p.Imports, p.ImportPos = cleanDecls(importPos)
	1001  	p.TestImports, p.TestImportPos = cleanDecls(testImportPos)
	1002  	p.XTestImports, p.XTestImportPos = cleanDecls(xTestImportPos)
	1003  
	1004  	// add the .S/.sx files only if we are using cgo
	1005  	// (which means gcc will compile them).
	1006  	// The standard assemblers expect .s files.
	1007  	if len(p.CgoFiles) > 0 {
	1008  		p.SFiles = append(p.SFiles, Sfiles...)
	1009  		sort.Strings(p.SFiles)
	1010  	} else {
	1011  		p.IgnoredOtherFiles = append(p.IgnoredOtherFiles, Sfiles...)
	1012  		sort.Strings(p.IgnoredOtherFiles)
	1013  	}
	1014  
	1015  	if badGoError != nil {
	1016  		return p, badGoError
	1017  	}
	1018  	if len(p.GoFiles)+len(p.CgoFiles)+len(p.TestGoFiles)+len(p.XTestGoFiles) == 0 {
	1019  		return p, &NoGoError{p.Dir}
	1020  	}
	1021  	return p, pkgerr
	1022  }
	1023  
	1024  func fileListForExt(p *Package, ext string) *[]string {
	1025  	switch ext {
	1026  	case ".c":
	1027  		return &p.CFiles
	1028  	case ".cc", ".cpp", ".cxx":
	1029  		return &p.CXXFiles
	1030  	case ".m":
	1031  		return &p.MFiles
	1032  	case ".h", ".hh", ".hpp", ".hxx":
	1033  		return &p.HFiles
	1034  	case ".f", ".F", ".for", ".f90":
	1035  		return &p.FFiles
	1036  	case ".s", ".S", ".sx":
	1037  		return &p.SFiles
	1038  	case ".swig":
	1039  		return &p.SwigFiles
	1040  	case ".swigcxx":
	1041  		return &p.SwigCXXFiles
	1042  	case ".syso":
	1043  		return &p.SysoFiles
	1044  	}
	1045  	return nil
	1046  }
	1047  
	1048  func uniq(list []string) []string {
	1049  	if list == nil {
	1050  		return nil
	1051  	}
	1052  	out := make([]string, len(list))
	1053  	copy(out, list)
	1054  	sort.Strings(out)
	1055  	uniq := out[:0]
	1056  	for _, x := range out {
	1057  		if len(uniq) == 0 || uniq[len(uniq)-1] != x {
	1058  			uniq = append(uniq, x)
	1059  		}
	1060  	}
	1061  	return uniq
	1062  }
	1063  
	1064  var errNoModules = errors.New("not using modules")
	1065  
	1066  // importGo checks whether it can use the go command to find the directory for path.
	1067  // If using the go command is not appropriate, importGo returns errNoModules.
	1068  // Otherwise, importGo tries using the go command and reports whether that succeeded.
	1069  // Using the go command lets build.Import and build.Context.Import find code
	1070  // in Go modules. In the long term we want tools to use go/packages (currently golang.org/x/tools/go/packages),
	1071  // which will also use the go command.
	1072  // Invoking the go command here is not very efficient in that it computes information
	1073  // about the requested package and all dependencies and then only reports about the requested package.
	1074  // Then we reinvoke it for every dependency. But this is still better than not working at all.
	1075  // See golang.org/issue/26504.
	1076  func (ctxt *Context) importGo(p *Package, path, srcDir string, mode ImportMode) error {
	1077  	// To invoke the go command,
	1078  	// we must not being doing special things like AllowBinary or IgnoreVendor,
	1079  	// and all the file system callbacks must be nil (we're meant to use the local file system).
	1080  	if mode&AllowBinary != 0 || mode&IgnoreVendor != 0 ||
	1081  		ctxt.JoinPath != nil || ctxt.SplitPathList != nil || ctxt.IsAbsPath != nil || ctxt.IsDir != nil || ctxt.HasSubdir != nil || ctxt.ReadDir != nil || ctxt.OpenFile != nil || !equal(ctxt.ToolTags, defaultToolTags) || !equal(ctxt.ReleaseTags, defaultReleaseTags) {
	1082  		return errNoModules
	1083  	}
	1084  
	1085  	// Predict whether module aware mode is enabled by checking the value of
	1086  	// GO111MODULE and looking for a go.mod file in the source directory or
	1087  	// one of its parents. Running 'go env GOMOD' in the source directory would
	1088  	// give a canonical answer, but we'd prefer not to execute another command.
	1089  	go111Module := os.Getenv("GO111MODULE")
	1090  	switch go111Module {
	1091  	case "off":
	1092  		return errNoModules
	1093  	default: // "", "on", "auto", anything else
	1094  		// Maybe use modules.
	1095  	}
	1096  
	1097  	if srcDir != "" {
	1098  		var absSrcDir string
	1099  		if filepath.IsAbs(srcDir) {
	1100  			absSrcDir = srcDir
	1101  		} else if ctxt.Dir != "" {
	1102  			return fmt.Errorf("go/build: Dir is non-empty, so relative srcDir is not allowed: %v", srcDir)
	1103  		} else {
	1104  			// Find the absolute source directory. hasSubdir does not handle
	1105  			// relative paths (and can't because the callbacks don't support this).
	1106  			var err error
	1107  			absSrcDir, err = filepath.Abs(srcDir)
	1108  			if err != nil {
	1109  				return errNoModules
	1110  			}
	1111  		}
	1112  
	1113  		// If the source directory is in GOROOT, then the in-process code works fine
	1114  		// and we should keep using it. Moreover, the 'go list' approach below doesn't
	1115  		// take standard-library vendoring into account and will fail.
	1116  		if _, ok := ctxt.hasSubdir(filepath.Join(ctxt.GOROOT, "src"), absSrcDir); ok {
	1117  			return errNoModules
	1118  		}
	1119  	}
	1120  
	1121  	// For efficiency, if path is a standard library package, let the usual lookup code handle it.
	1122  	if ctxt.GOROOT != "" {
	1123  		dir := ctxt.joinPath(ctxt.GOROOT, "src", path)
	1124  		if ctxt.isDir(dir) {
	1125  			return errNoModules
	1126  		}
	1127  	}
	1128  
	1129  	// If GO111MODULE=auto, look to see if there is a go.mod.
	1130  	// Since go1.13, it doesn't matter if we're inside GOPATH.
	1131  	if go111Module == "auto" {
	1132  		var (
	1133  			parent string
	1134  			err		error
	1135  		)
	1136  		if ctxt.Dir == "" {
	1137  			parent, err = os.Getwd()
	1138  			if err != nil {
	1139  				// A nonexistent working directory can't be in a module.
	1140  				return errNoModules
	1141  			}
	1142  		} else {
	1143  			parent, err = filepath.Abs(ctxt.Dir)
	1144  			if err != nil {
	1145  				// If the caller passed a bogus Dir explicitly, that's materially
	1146  				// different from not having modules enabled.
	1147  				return err
	1148  			}
	1149  		}
	1150  		for {
	1151  			if f, err := ctxt.openFile(ctxt.joinPath(parent, "go.mod")); err == nil {
	1152  				buf := make([]byte, 100)
	1153  				_, err := f.Read(buf)
	1154  				f.Close()
	1155  				if err == nil || err == io.EOF {
	1156  					// go.mod exists and is readable (is a file, not a directory).
	1157  					break
	1158  				}
	1159  			}
	1160  			d := filepath.Dir(parent)
	1161  			if len(d) >= len(parent) {
	1162  				return errNoModules // reached top of file system, no go.mod
	1163  			}
	1164  			parent = d
	1165  		}
	1166  	}
	1167  
	1168  	cmd := exec.Command("go", "list", "-e", "-compiler="+ctxt.Compiler, "-tags="+strings.Join(ctxt.BuildTags, ","), "-installsuffix="+ctxt.InstallSuffix, "-f={{.Dir}}\n{{.ImportPath}}\n{{.Root}}\n{{.Goroot}}\n{{if .Error}}{{.Error}}{{end}}\n", "--", path)
	1169  
	1170  	if ctxt.Dir != "" {
	1171  		cmd.Dir = ctxt.Dir
	1172  	}
	1173  
	1174  	var stdout, stderr strings.Builder
	1175  	cmd.Stdout = &stdout
	1176  	cmd.Stderr = &stderr
	1177  
	1178  	cgo := "0"
	1179  	if ctxt.CgoEnabled {
	1180  		cgo = "1"
	1181  	}
	1182  	cmd.Env = append(os.Environ(),
	1183  		"GOOS="+ctxt.GOOS,
	1184  		"GOARCH="+ctxt.GOARCH,
	1185  		"GOROOT="+ctxt.GOROOT,
	1186  		"GOPATH="+ctxt.GOPATH,
	1187  		"CGO_ENABLED="+cgo,
	1188  	)
	1189  
	1190  	if err := cmd.Run(); err != nil {
	1191  		return fmt.Errorf("go/build: go list %s: %v\n%s\n", path, err, stderr.String())
	1192  	}
	1193  
	1194  	f := strings.SplitN(stdout.String(), "\n", 5)
	1195  	if len(f) != 5 {
	1196  		return fmt.Errorf("go/build: importGo %s: unexpected output:\n%s\n", path, stdout.String())
	1197  	}
	1198  	dir := f[0]
	1199  	errStr := strings.TrimSpace(f[4])
	1200  	if errStr != "" && dir == "" {
	1201  		// If 'go list' could not locate the package (dir is empty),
	1202  		// return the same error that 'go list' reported.
	1203  		return errors.New(errStr)
	1204  	}
	1205  
	1206  	// If 'go list' did locate the package, ignore the error.
	1207  	// It was probably related to loading source files, and we'll
	1208  	// encounter it ourselves shortly if the FindOnly flag isn't set.
	1209  	p.Dir = dir
	1210  	p.ImportPath = f[1]
	1211  	p.Root = f[2]
	1212  	p.Goroot = f[3] == "true"
	1213  	return nil
	1214  }
	1215  
	1216  func equal(x, y []string) bool {
	1217  	if len(x) != len(y) {
	1218  		return false
	1219  	}
	1220  	for i, xi := range x {
	1221  		if xi != y[i] {
	1222  			return false
	1223  		}
	1224  	}
	1225  	return true
	1226  }
	1227  
	1228  // hasGoFiles reports whether dir contains any files with names ending in .go.
	1229  // For a vendor check we must exclude directories that contain no .go files.
	1230  // Otherwise it is not possible to vendor just a/b/c and still import the
	1231  // non-vendored a/b. See golang.org/issue/13832.
	1232  func hasGoFiles(ctxt *Context, dir string) bool {
	1233  	ents, _ := ctxt.readDir(dir)
	1234  	for _, ent := range ents {
	1235  		if !ent.IsDir() && strings.HasSuffix(ent.Name(), ".go") {
	1236  			return true
	1237  		}
	1238  	}
	1239  	return false
	1240  }
	1241  
	1242  func findImportComment(data []byte) (s string, line int) {
	1243  	// expect keyword package
	1244  	word, data := parseWord(data)
	1245  	if string(word) != "package" {
	1246  		return "", 0
	1247  	}
	1248  
	1249  	// expect package name
	1250  	_, data = parseWord(data)
	1251  
	1252  	// now ready for import comment, a // or /* */ comment
	1253  	// beginning and ending on the current line.
	1254  	for len(data) > 0 && (data[0] == ' ' || data[0] == '\t' || data[0] == '\r') {
	1255  		data = data[1:]
	1256  	}
	1257  
	1258  	var comment []byte
	1259  	switch {
	1260  	case bytes.HasPrefix(data, slashSlash):
	1261  		i := bytes.Index(data, newline)
	1262  		if i < 0 {
	1263  			i = len(data)
	1264  		}
	1265  		comment = data[2:i]
	1266  	case bytes.HasPrefix(data, slashStar):
	1267  		data = data[2:]
	1268  		i := bytes.Index(data, starSlash)
	1269  		if i < 0 {
	1270  			// malformed comment
	1271  			return "", 0
	1272  		}
	1273  		comment = data[:i]
	1274  		if bytes.Contains(comment, newline) {
	1275  			return "", 0
	1276  		}
	1277  	}
	1278  	comment = bytes.TrimSpace(comment)
	1279  
	1280  	// split comment into `import`, `"pkg"`
	1281  	word, arg := parseWord(comment)
	1282  	if string(word) != "import" {
	1283  		return "", 0
	1284  	}
	1285  
	1286  	line = 1 + bytes.Count(data[:cap(data)-cap(arg)], newline)
	1287  	return strings.TrimSpace(string(arg)), line
	1288  }
	1289  
	1290  var (
	1291  	slashSlash = []byte("//")
	1292  	slashStar	= []byte("/*")
	1293  	starSlash	= []byte("*/")
	1294  	newline		= []byte("\n")
	1295  )
	1296  
	1297  // skipSpaceOrComment returns data with any leading spaces or comments removed.
	1298  func skipSpaceOrComment(data []byte) []byte {
	1299  	for len(data) > 0 {
	1300  		switch data[0] {
	1301  		case ' ', '\t', '\r', '\n':
	1302  			data = data[1:]
	1303  			continue
	1304  		case '/':
	1305  			if bytes.HasPrefix(data, slashSlash) {
	1306  				i := bytes.Index(data, newline)
	1307  				if i < 0 {
	1308  					return nil
	1309  				}
	1310  				data = data[i+1:]
	1311  				continue
	1312  			}
	1313  			if bytes.HasPrefix(data, slashStar) {
	1314  				data = data[2:]
	1315  				i := bytes.Index(data, starSlash)
	1316  				if i < 0 {
	1317  					return nil
	1318  				}
	1319  				data = data[i+2:]
	1320  				continue
	1321  			}
	1322  		}
	1323  		break
	1324  	}
	1325  	return data
	1326  }
	1327  
	1328  // parseWord skips any leading spaces or comments in data
	1329  // and then parses the beginning of data as an identifier or keyword,
	1330  // returning that word and what remains after the word.
	1331  func parseWord(data []byte) (word, rest []byte) {
	1332  	data = skipSpaceOrComment(data)
	1333  
	1334  	// Parse past leading word characters.
	1335  	rest = data
	1336  	for {
	1337  		r, size := utf8.DecodeRune(rest)
	1338  		if unicode.IsLetter(r) || '0' <= r && r <= '9' || r == '_' {
	1339  			rest = rest[size:]
	1340  			continue
	1341  		}
	1342  		break
	1343  	}
	1344  
	1345  	word = data[:len(data)-len(rest)]
	1346  	if len(word) == 0 {
	1347  		return nil, nil
	1348  	}
	1349  
	1350  	return word, rest
	1351  }
	1352  
	1353  // MatchFile reports whether the file with the given name in the given directory
	1354  // matches the context and would be included in a Package created by ImportDir
	1355  // of that directory.
	1356  //
	1357  // MatchFile considers the name of the file and may use ctxt.OpenFile to
	1358  // read some or all of the file's content.
	1359  func (ctxt *Context) MatchFile(dir, name string) (match bool, err error) {
	1360  	info, err := ctxt.matchFile(dir, name, nil, nil, nil)
	1361  	return info != nil, err
	1362  }
	1363  
	1364  var dummyPkg Package
	1365  
	1366  // fileInfo records information learned about a file included in a build.
	1367  type fileInfo struct {
	1368  	name		 string // full name including dir
	1369  	header	 []byte
	1370  	fset		 *token.FileSet
	1371  	parsed	 *ast.File
	1372  	parseErr error
	1373  	imports	[]fileImport
	1374  	embeds	 []fileEmbed
	1375  	embedErr error
	1376  }
	1377  
	1378  type fileImport struct {
	1379  	path string
	1380  	pos	token.Pos
	1381  	doc	*ast.CommentGroup
	1382  }
	1383  
	1384  type fileEmbed struct {
	1385  	pattern string
	1386  	pos		 token.Position
	1387  }
	1388  
	1389  // matchFile determines whether the file with the given name in the given directory
	1390  // should be included in the package being constructed.
	1391  // If the file should be included, matchFile returns a non-nil *fileInfo (and a nil error).
	1392  // Non-nil errors are reserved for unexpected problems.
	1393  //
	1394  // If name denotes a Go program, matchFile reads until the end of the
	1395  // imports and returns that section of the file in the fileInfo's header field,
	1396  // even though it only considers text until the first non-comment
	1397  // for +build lines.
	1398  //
	1399  // If allTags is non-nil, matchFile records any encountered build tag
	1400  // by setting allTags[tag] = true.
	1401  func (ctxt *Context) matchFile(dir, name string, allTags map[string]bool, binaryOnly *bool, fset *token.FileSet) (*fileInfo, error) {
	1402  	if strings.HasPrefix(name, "_") ||
	1403  		strings.HasPrefix(name, ".") {
	1404  		return nil, nil
	1405  	}
	1406  
	1407  	i := strings.LastIndex(name, ".")
	1408  	if i < 0 {
	1409  		i = len(name)
	1410  	}
	1411  	ext := name[i:]
	1412  
	1413  	if !ctxt.goodOSArchFile(name, allTags) && !ctxt.UseAllFiles {
	1414  		return nil, nil
	1415  	}
	1416  
	1417  	if ext != ".go" && fileListForExt(&dummyPkg, ext) == nil {
	1418  		// skip
	1419  		return nil, nil
	1420  	}
	1421  
	1422  	info := &fileInfo{name: ctxt.joinPath(dir, name), fset: fset}
	1423  	if ext == ".syso" {
	1424  		// binary, no reading
	1425  		return info, nil
	1426  	}
	1427  
	1428  	f, err := ctxt.openFile(info.name)
	1429  	if err != nil {
	1430  		return nil, err
	1431  	}
	1432  
	1433  	if strings.HasSuffix(name, ".go") {
	1434  		err = readGoInfo(f, info)
	1435  		if strings.HasSuffix(name, "_test.go") {
	1436  			binaryOnly = nil // ignore //go:binary-only-package comments in _test.go files
	1437  		}
	1438  	} else {
	1439  		binaryOnly = nil // ignore //go:binary-only-package comments in non-Go sources
	1440  		info.header, err = readComments(f)
	1441  	}
	1442  	f.Close()
	1443  	if err != nil {
	1444  		return nil, fmt.Errorf("read %s: %v", info.name, err)
	1445  	}
	1446  
	1447  	// Look for +build comments to accept or reject the file.
	1448  	ok, sawBinaryOnly, err := ctxt.shouldBuild(info.header, allTags)
	1449  	if err != nil {
	1450  		return nil, fmt.Errorf("%s: %v", name, err)
	1451  	}
	1452  	if !ok && !ctxt.UseAllFiles {
	1453  		return nil, nil
	1454  	}
	1455  
	1456  	if binaryOnly != nil && sawBinaryOnly {
	1457  		*binaryOnly = true
	1458  	}
	1459  
	1460  	return info, nil
	1461  }
	1462  
	1463  func cleanDecls(m map[string][]token.Position) ([]string, map[string][]token.Position) {
	1464  	all := make([]string, 0, len(m))
	1465  	for path := range m {
	1466  		all = append(all, path)
	1467  	}
	1468  	sort.Strings(all)
	1469  	return all, m
	1470  }
	1471  
	1472  // Import is shorthand for Default.Import.
	1473  func Import(path, srcDir string, mode ImportMode) (*Package, error) {
	1474  	return Default.Import(path, srcDir, mode)
	1475  }
	1476  
	1477  // ImportDir is shorthand for Default.ImportDir.
	1478  func ImportDir(dir string, mode ImportMode) (*Package, error) {
	1479  	return Default.ImportDir(dir, mode)
	1480  }
	1481  
	1482  var (
	1483  	bSlashSlash = []byte(slashSlash)
	1484  	bStarSlash	= []byte(starSlash)
	1485  	bSlashStar	= []byte(slashStar)
	1486  	bPlusBuild	= []byte("+build")
	1487  
	1488  	goBuildComment = []byte("//go:build")
	1489  
	1490  	errGoBuildWithoutBuild = errors.New("//go:build comment without // +build comment")
	1491  	errMultipleGoBuild		 = errors.New("multiple //go:build comments")
	1492  )
	1493  
	1494  func isGoBuildComment(line []byte) bool {
	1495  	if !bytes.HasPrefix(line, goBuildComment) {
	1496  		return false
	1497  	}
	1498  	line = bytes.TrimSpace(line)
	1499  	rest := line[len(goBuildComment):]
	1500  	return len(rest) == 0 || len(bytes.TrimSpace(rest)) < len(rest)
	1501  }
	1502  
	1503  // Special comment denoting a binary-only package.
	1504  // See https://golang.org/design/2775-binary-only-packages
	1505  // for more about the design of binary-only packages.
	1506  var binaryOnlyComment = []byte("//go:binary-only-package")
	1507  
	1508  // shouldBuild reports whether it is okay to use this file,
	1509  // The rule is that in the file's leading run of // comments
	1510  // and blank lines, which must be followed by a blank line
	1511  // (to avoid including a Go package clause doc comment),
	1512  // lines beginning with '// +build' are taken as build directives.
	1513  //
	1514  // The file is accepted only if each such line lists something
	1515  // matching the file. For example:
	1516  //
	1517  //	// +build windows linux
	1518  //
	1519  // marks the file as applicable only on Windows and Linux.
	1520  //
	1521  // For each build tag it consults, shouldBuild sets allTags[tag] = true.
	1522  //
	1523  // shouldBuild reports whether the file should be built
	1524  // and whether a //go:binary-only-package comment was found.
	1525  func (ctxt *Context) shouldBuild(content []byte, allTags map[string]bool) (shouldBuild, binaryOnly bool, err error) {
	1526  	// Identify leading run of // comments and blank lines,
	1527  	// which must be followed by a blank line.
	1528  	// Also identify any //go:build comments.
	1529  	content, goBuild, sawBinaryOnly, err := parseFileHeader(content)
	1530  	if err != nil {
	1531  		return false, false, err
	1532  	}
	1533  
	1534  	// If //go:build line is present, it controls.
	1535  	// Otherwise fall back to +build processing.
	1536  	switch {
	1537  	case goBuild != nil:
	1538  		x, err := constraint.Parse(string(goBuild))
	1539  		if err != nil {
	1540  			return false, false, fmt.Errorf("parsing //go:build line: %v", err)
	1541  		}
	1542  		shouldBuild = ctxt.eval(x, allTags)
	1543  
	1544  	default:
	1545  		shouldBuild = true
	1546  		p := content
	1547  		for len(p) > 0 {
	1548  			line := p
	1549  			if i := bytes.IndexByte(line, '\n'); i >= 0 {
	1550  				line, p = line[:i], p[i+1:]
	1551  			} else {
	1552  				p = p[len(p):]
	1553  			}
	1554  			line = bytes.TrimSpace(line)
	1555  			if !bytes.HasPrefix(line, bSlashSlash) || !bytes.Contains(line, bPlusBuild) {
	1556  				continue
	1557  			}
	1558  			text := string(line)
	1559  			if !constraint.IsPlusBuild(text) {
	1560  				continue
	1561  			}
	1562  			if x, err := constraint.Parse(text); err == nil {
	1563  				if !ctxt.eval(x, allTags) {
	1564  					shouldBuild = false
	1565  				}
	1566  			}
	1567  		}
	1568  	}
	1569  
	1570  	return shouldBuild, sawBinaryOnly, nil
	1571  }
	1572  
	1573  func parseFileHeader(content []byte) (trimmed, goBuild []byte, sawBinaryOnly bool, err error) {
	1574  	end := 0
	1575  	p := content
	1576  	ended := false			 // found non-blank, non-// line, so stopped accepting // +build lines
	1577  	inSlashStar := false // in /* */ comment
	1578  
	1579  Lines:
	1580  	for len(p) > 0 {
	1581  		line := p
	1582  		if i := bytes.IndexByte(line, '\n'); i >= 0 {
	1583  			line, p = line[:i], p[i+1:]
	1584  		} else {
	1585  			p = p[len(p):]
	1586  		}
	1587  		line = bytes.TrimSpace(line)
	1588  		if len(line) == 0 && !ended { // Blank line
	1589  			// Remember position of most recent blank line.
	1590  			// When we find the first non-blank, non-// line,
	1591  			// this "end" position marks the latest file position
	1592  			// where a // +build line can appear.
	1593  			// (It must appear _before_ a blank line before the non-blank, non-// line.
	1594  			// Yes, that's confusing, which is part of why we moved to //go:build lines.)
	1595  			// Note that ended==false here means that inSlashStar==false,
	1596  			// since seeing a /* would have set ended==true.
	1597  			end = len(content) - len(p)
	1598  			continue Lines
	1599  		}
	1600  		if !bytes.HasPrefix(line, slashSlash) { // Not comment line
	1601  			ended = true
	1602  		}
	1603  
	1604  		if !inSlashStar && isGoBuildComment(line) {
	1605  			if goBuild != nil {
	1606  				return nil, nil, false, errMultipleGoBuild
	1607  			}
	1608  			goBuild = line
	1609  		}
	1610  		if !inSlashStar && bytes.Equal(line, binaryOnlyComment) {
	1611  			sawBinaryOnly = true
	1612  		}
	1613  
	1614  	Comments:
	1615  		for len(line) > 0 {
	1616  			if inSlashStar {
	1617  				if i := bytes.Index(line, starSlash); i >= 0 {
	1618  					inSlashStar = false
	1619  					line = bytes.TrimSpace(line[i+len(starSlash):])
	1620  					continue Comments
	1621  				}
	1622  				continue Lines
	1623  			}
	1624  			if bytes.HasPrefix(line, bSlashSlash) {
	1625  				continue Lines
	1626  			}
	1627  			if bytes.HasPrefix(line, bSlashStar) {
	1628  				inSlashStar = true
	1629  				line = bytes.TrimSpace(line[len(bSlashStar):])
	1630  				continue Comments
	1631  			}
	1632  			// Found non-comment text.
	1633  			break Lines
	1634  		}
	1635  	}
	1636  
	1637  	return content[:end], goBuild, sawBinaryOnly, nil
	1638  }
	1639  
	1640  // saveCgo saves the information from the #cgo lines in the import "C" comment.
	1641  // These lines set CFLAGS, CPPFLAGS, CXXFLAGS and LDFLAGS and pkg-config directives
	1642  // that affect the way cgo's C code is built.
	1643  func (ctxt *Context) saveCgo(filename string, di *Package, cg *ast.CommentGroup) error {
	1644  	text := cg.Text()
	1645  	for _, line := range strings.Split(text, "\n") {
	1646  		orig := line
	1647  
	1648  		// Line is
	1649  		//	#cgo [GOOS/GOARCH...] LDFLAGS: stuff
	1650  		//
	1651  		line = strings.TrimSpace(line)
	1652  		if len(line) < 5 || line[:4] != "#cgo" || (line[4] != ' ' && line[4] != '\t') {
	1653  			continue
	1654  		}
	1655  
	1656  		// Split at colon.
	1657  		line = strings.TrimSpace(line[4:])
	1658  		i := strings.Index(line, ":")
	1659  		if i < 0 {
	1660  			return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
	1661  		}
	1662  		line, argstr := line[:i], line[i+1:]
	1663  
	1664  		// Parse GOOS/GOARCH stuff.
	1665  		f := strings.Fields(line)
	1666  		if len(f) < 1 {
	1667  			return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
	1668  		}
	1669  
	1670  		cond, verb := f[:len(f)-1], f[len(f)-1]
	1671  		if len(cond) > 0 {
	1672  			ok := false
	1673  			for _, c := range cond {
	1674  				if ctxt.matchAuto(c, nil) {
	1675  					ok = true
	1676  					break
	1677  				}
	1678  			}
	1679  			if !ok {
	1680  				continue
	1681  			}
	1682  		}
	1683  
	1684  		args, err := splitQuoted(argstr)
	1685  		if err != nil {
	1686  			return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
	1687  		}
	1688  		var ok bool
	1689  		for i, arg := range args {
	1690  			if arg, ok = expandSrcDir(arg, di.Dir); !ok {
	1691  				return fmt.Errorf("%s: malformed #cgo argument: %s", filename, arg)
	1692  			}
	1693  			args[i] = arg
	1694  		}
	1695  
	1696  		switch verb {
	1697  		case "CFLAGS", "CPPFLAGS", "CXXFLAGS", "FFLAGS", "LDFLAGS":
	1698  			// Change relative paths to absolute.
	1699  			ctxt.makePathsAbsolute(args, di.Dir)
	1700  		}
	1701  
	1702  		switch verb {
	1703  		case "CFLAGS":
	1704  			di.CgoCFLAGS = append(di.CgoCFLAGS, args...)
	1705  		case "CPPFLAGS":
	1706  			di.CgoCPPFLAGS = append(di.CgoCPPFLAGS, args...)
	1707  		case "CXXFLAGS":
	1708  			di.CgoCXXFLAGS = append(di.CgoCXXFLAGS, args...)
	1709  		case "FFLAGS":
	1710  			di.CgoFFLAGS = append(di.CgoFFLAGS, args...)
	1711  		case "LDFLAGS":
	1712  			di.CgoLDFLAGS = append(di.CgoLDFLAGS, args...)
	1713  		case "pkg-config":
	1714  			di.CgoPkgConfig = append(di.CgoPkgConfig, args...)
	1715  		default:
	1716  			return fmt.Errorf("%s: invalid #cgo verb: %s", filename, orig)
	1717  		}
	1718  	}
	1719  	return nil
	1720  }
	1721  
	1722  // expandSrcDir expands any occurrence of ${SRCDIR}, making sure
	1723  // the result is safe for the shell.
	1724  func expandSrcDir(str string, srcdir string) (string, bool) {
	1725  	// "\" delimited paths cause safeCgoName to fail
	1726  	// so convert native paths with a different delimiter
	1727  	// to "/" before starting (eg: on windows).
	1728  	srcdir = filepath.ToSlash(srcdir)
	1729  
	1730  	chunks := strings.Split(str, "${SRCDIR}")
	1731  	if len(chunks) < 2 {
	1732  		return str, safeCgoName(str)
	1733  	}
	1734  	ok := true
	1735  	for _, chunk := range chunks {
	1736  		ok = ok && (chunk == "" || safeCgoName(chunk))
	1737  	}
	1738  	ok = ok && (srcdir == "" || safeCgoName(srcdir))
	1739  	res := strings.Join(chunks, srcdir)
	1740  	return res, ok && res != ""
	1741  }
	1742  
	1743  // makePathsAbsolute looks for compiler options that take paths and
	1744  // makes them absolute. We do this because through the 1.8 release we
	1745  // ran the compiler in the package directory, so any relative -I or -L
	1746  // options would be relative to that directory. In 1.9 we changed to
	1747  // running the compiler in the build directory, to get consistent
	1748  // build results (issue #19964). To keep builds working, we change any
	1749  // relative -I or -L options to be absolute.
	1750  //
	1751  // Using filepath.IsAbs and filepath.Join here means the results will be
	1752  // different on different systems, but that's OK: -I and -L options are
	1753  // inherently system-dependent.
	1754  func (ctxt *Context) makePathsAbsolute(args []string, srcDir string) {
	1755  	nextPath := false
	1756  	for i, arg := range args {
	1757  		if nextPath {
	1758  			if !filepath.IsAbs(arg) {
	1759  				args[i] = filepath.Join(srcDir, arg)
	1760  			}
	1761  			nextPath = false
	1762  		} else if strings.HasPrefix(arg, "-I") || strings.HasPrefix(arg, "-L") {
	1763  			if len(arg) == 2 {
	1764  				nextPath = true
	1765  			} else {
	1766  				if !filepath.IsAbs(arg[2:]) {
	1767  					args[i] = arg[:2] + filepath.Join(srcDir, arg[2:])
	1768  				}
	1769  			}
	1770  		}
	1771  	}
	1772  }
	1773  
	1774  // NOTE: $ is not safe for the shell, but it is allowed here because of linker options like -Wl,$ORIGIN.
	1775  // We never pass these arguments to a shell (just to programs we construct argv for), so this should be okay.
	1776  // See golang.org/issue/6038.
	1777  // The @ is for OS X. See golang.org/issue/13720.
	1778  // The % is for Jenkins. See golang.org/issue/16959.
	1779  // The ! is because module paths may use them. See golang.org/issue/26716.
	1780  // The ~ and ^ are for sr.ht. See golang.org/issue/32260.
	1781  const safeString = "+-.,/0123456789=ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz:$@%! ~^"
	1782  
	1783  func safeCgoName(s string) bool {
	1784  	if s == "" {
	1785  		return false
	1786  	}
	1787  	for i := 0; i < len(s); i++ {
	1788  		if c := s[i]; c < utf8.RuneSelf && strings.IndexByte(safeString, c) < 0 {
	1789  			return false
	1790  		}
	1791  	}
	1792  	return true
	1793  }
	1794  
	1795  // splitQuoted splits the string s around each instance of one or more consecutive
	1796  // white space characters while taking into account quotes and escaping, and
	1797  // returns an array of substrings of s or an empty list if s contains only white space.
	1798  // Single quotes and double quotes are recognized to prevent splitting within the
	1799  // quoted region, and are removed from the resulting substrings. If a quote in s
	1800  // isn't closed err will be set and r will have the unclosed argument as the
	1801  // last element. The backslash is used for escaping.
	1802  //
	1803  // For example, the following string:
	1804  //
	1805  //		 a b:"c d" 'e''f'	"g\""
	1806  //
	1807  // Would be parsed as:
	1808  //
	1809  //		 []string{"a", "b:c d", "ef", `g"`}
	1810  //
	1811  func splitQuoted(s string) (r []string, err error) {
	1812  	var args []string
	1813  	arg := make([]rune, len(s))
	1814  	escaped := false
	1815  	quoted := false
	1816  	quote := '\x00'
	1817  	i := 0
	1818  	for _, rune := range s {
	1819  		switch {
	1820  		case escaped:
	1821  			escaped = false
	1822  		case rune == '\\':
	1823  			escaped = true
	1824  			continue
	1825  		case quote != '\x00':
	1826  			if rune == quote {
	1827  				quote = '\x00'
	1828  				continue
	1829  			}
	1830  		case rune == '"' || rune == '\'':
	1831  			quoted = true
	1832  			quote = rune
	1833  			continue
	1834  		case unicode.IsSpace(rune):
	1835  			if quoted || i > 0 {
	1836  				quoted = false
	1837  				args = append(args, string(arg[:i]))
	1838  				i = 0
	1839  			}
	1840  			continue
	1841  		}
	1842  		arg[i] = rune
	1843  		i++
	1844  	}
	1845  	if quoted || i > 0 {
	1846  		args = append(args, string(arg[:i]))
	1847  	}
	1848  	if quote != 0 {
	1849  		err = errors.New("unclosed quote")
	1850  	} else if escaped {
	1851  		err = errors.New("unfinished escaping")
	1852  	}
	1853  	return args, err
	1854  }
	1855  
	1856  // matchAuto interprets text as either a +build or //go:build expression (whichever works),
	1857  // reporting whether the expression matches the build context.
	1858  //
	1859  // matchAuto is only used for testing of tag evaluation
	1860  // and in #cgo lines, which accept either syntax.
	1861  func (ctxt *Context) matchAuto(text string, allTags map[string]bool) bool {
	1862  	if strings.ContainsAny(text, "&|()") {
	1863  		text = "//go:build " + text
	1864  	} else {
	1865  		text = "// +build " + text
	1866  	}
	1867  	x, err := constraint.Parse(text)
	1868  	if err != nil {
	1869  		return false
	1870  	}
	1871  	return ctxt.eval(x, allTags)
	1872  }
	1873  
	1874  func (ctxt *Context) eval(x constraint.Expr, allTags map[string]bool) bool {
	1875  	return x.Eval(func(tag string) bool { return ctxt.matchTag(tag, allTags) })
	1876  }
	1877  
	1878  // matchTag reports whether the name is one of:
	1879  //
	1880  //	cgo (if cgo is enabled)
	1881  //	$GOOS
	1882  //	$GOARCH
	1883  //	ctxt.Compiler
	1884  //	linux (if GOOS = android)
	1885  //	solaris (if GOOS = illumos)
	1886  //	tag (if tag is listed in ctxt.BuildTags or ctxt.ReleaseTags)
	1887  //
	1888  // It records all consulted tags in allTags.
	1889  func (ctxt *Context) matchTag(name string, allTags map[string]bool) bool {
	1890  	if allTags != nil {
	1891  		allTags[name] = true
	1892  	}
	1893  
	1894  	// special tags
	1895  	if ctxt.CgoEnabled && name == "cgo" {
	1896  		return true
	1897  	}
	1898  	if name == ctxt.GOOS || name == ctxt.GOARCH || name == ctxt.Compiler {
	1899  		return true
	1900  	}
	1901  	if ctxt.GOOS == "android" && name == "linux" {
	1902  		return true
	1903  	}
	1904  	if ctxt.GOOS == "illumos" && name == "solaris" {
	1905  		return true
	1906  	}
	1907  	if ctxt.GOOS == "ios" && name == "darwin" {
	1908  		return true
	1909  	}
	1910  
	1911  	// other tags
	1912  	for _, tag := range ctxt.BuildTags {
	1913  		if tag == name {
	1914  			return true
	1915  		}
	1916  	}
	1917  	for _, tag := range ctxt.ToolTags {
	1918  		if tag == name {
	1919  			return true
	1920  		}
	1921  	}
	1922  	for _, tag := range ctxt.ReleaseTags {
	1923  		if tag == name {
	1924  			return true
	1925  		}
	1926  	}
	1927  
	1928  	return false
	1929  }
	1930  
	1931  // goodOSArchFile returns false if the name contains a $GOOS or $GOARCH
	1932  // suffix which does not match the current system.
	1933  // The recognized name formats are:
	1934  //
	1935  //		 name_$(GOOS).*
	1936  //		 name_$(GOARCH).*
	1937  //		 name_$(GOOS)_$(GOARCH).*
	1938  //		 name_$(GOOS)_test.*
	1939  //		 name_$(GOARCH)_test.*
	1940  //		 name_$(GOOS)_$(GOARCH)_test.*
	1941  //
	1942  // Exceptions:
	1943  // if GOOS=android, then files with GOOS=linux are also matched.
	1944  // if GOOS=illumos, then files with GOOS=solaris are also matched.
	1945  // if GOOS=ios, then files with GOOS=darwin are also matched.
	1946  func (ctxt *Context) goodOSArchFile(name string, allTags map[string]bool) bool {
	1947  	if dot := strings.Index(name, "."); dot != -1 {
	1948  		name = name[:dot]
	1949  	}
	1950  
	1951  	// Before Go 1.4, a file called "linux.go" would be equivalent to having a
	1952  	// build tag "linux" in that file. For Go 1.4 and beyond, we require this
	1953  	// auto-tagging to apply only to files with a non-empty prefix, so
	1954  	// "foo_linux.go" is tagged but "linux.go" is not. This allows new operating
	1955  	// systems, such as android, to arrive without breaking existing code with
	1956  	// innocuous source code in "android.go". The easiest fix: cut everything
	1957  	// in the name before the initial _.
	1958  	i := strings.Index(name, "_")
	1959  	if i < 0 {
	1960  		return true
	1961  	}
	1962  	name = name[i:] // ignore everything before first _
	1963  
	1964  	l := strings.Split(name, "_")
	1965  	if n := len(l); n > 0 && l[n-1] == "test" {
	1966  		l = l[:n-1]
	1967  	}
	1968  	n := len(l)
	1969  	if n >= 2 && knownOS[l[n-2]] && knownArch[l[n-1]] {
	1970  		return ctxt.matchTag(l[n-1], allTags) && ctxt.matchTag(l[n-2], allTags)
	1971  	}
	1972  	if n >= 1 && (knownOS[l[n-1]] || knownArch[l[n-1]]) {
	1973  		return ctxt.matchTag(l[n-1], allTags)
	1974  	}
	1975  	return true
	1976  }
	1977  
	1978  var knownOS = make(map[string]bool)
	1979  var knownArch = make(map[string]bool)
	1980  
	1981  func init() {
	1982  	for _, v := range strings.Fields(goosList) {
	1983  		knownOS[v] = true
	1984  	}
	1985  	for _, v := range strings.Fields(goarchList) {
	1986  		knownArch[v] = true
	1987  	}
	1988  }
	1989  
	1990  // ToolDir is the directory containing build tools.
	1991  var ToolDir = getToolDir()
	1992  
	1993  // IsLocalImport reports whether the import path is
	1994  // a local import path, like ".", "..", "./foo", or "../foo".
	1995  func IsLocalImport(path string) bool {
	1996  	return path == "." || path == ".." ||
	1997  		strings.HasPrefix(path, "./") || strings.HasPrefix(path, "../")
	1998  }
	1999  
	2000  // ArchChar returns "?" and an error.
	2001  // In earlier versions of Go, the returned string was used to derive
	2002  // the compiler and linker tool names, the default object file suffix,
	2003  // and the default linker output name. As of Go 1.5, those strings
	2004  // no longer vary by architecture; they are compile, link, .o, and a.out, respectively.
	2005  func ArchChar(goarch string) (string, error) {
	2006  	return "?", errors.New("architecture letter no longer used")
	2007  }
	2008  

View as plain text