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