Version: v0.0.0-...-07f7db3 Latest Latest

This package is not in the latest version of its module.

Go to latest
Published: Oct 11, 2017 License: BSD-3-Clause Imports: 27 Imported by: 0




This section is empty.


View Source
var BuildToolchain toolchain = noToolchain{}
View Source
var CmdBuild = &base.Command{
	UsageLine: "build [-o output] [-i] [build flags] [packages]",
	Short:     "compile packages and dependencies",
	Long: `
Build compiles the packages named by the import paths,
along with their dependencies, but it does not install the results.

If the arguments to build are a list of .go files, build treats
them as a list of source files specifying a single package.

When compiling a single main package, build writes
the resulting executable to an output file named after
the first source file ('go build ed.go rx.go' writes 'ed' or 'ed.exe')
or the source code directory ('go build unix/sam' writes 'sam' or 'sam.exe').
The '.exe' suffix is added when writing a Windows executable.

When compiling multiple packages or a single non-main package,
build compiles the packages but discards the resulting object,
serving only as a check that the packages can be built.

When compiling packages, build ignores files that end in '_test.go'.

The -o flag, only allowed when compiling a single package,
forces build to write the resulting executable or object
to the named output file, instead of the default behavior described
in the last two paragraphs.

The -i flag installs the packages that are dependencies of the target.

The build flags are shared by the build, clean, get, install, list, run,
and test commands:

		force rebuilding of packages that are already up-to-date.
		print the commands but do not run them.
	-p n
		the number of programs, such as build commands or
		test binaries, that can be run in parallel.
		The default is the number of CPUs available.
		enable data race detection.
		Supported only on linux/amd64, freebsd/amd64, darwin/amd64 and windows/amd64.
		enable interoperation with memory sanitizer.
		Supported only on linux/amd64,
		and only with Clang/LLVM as the host C compiler.
		print the names of packages as they are compiled.
		print the name of the temporary work directory and
		do not delete it when exiting.
		print the commands.

	-asmflags 'flag list'
		arguments to pass on each go tool asm invocation.
	-buildmode mode
		build mode to use. See 'go help buildmode' for more.
	-compiler name
		name of compiler to use, as in runtime.Compiler (gccgo or gc).
	-gccgoflags 'arg list'
		arguments to pass on each gccgo compiler/linker invocation.
	-gcflags 'arg list'
		arguments to pass on each go tool compile invocation.
	-installsuffix suffix
		a suffix to use in the name of the package installation directory,
		in order to keep output separate from default builds.
		If using the -race flag, the install suffix is automatically set to race
		or, if set explicitly, has _race appended to it. Likewise for the -msan
		flag. Using a -buildmode option that requires non-default compile flags
		has a similar effect.
	-ldflags 'flag list'
		arguments to pass on each go tool link invocation.
		link against shared libraries previously created with
	-pkgdir dir
		install and load all packages from dir instead of the usual locations.
		For example, when building with a non-standard configuration,
		use -pkgdir to keep generated packages in a separate location.
	-tags 'tag list'
		a space-separated list of build tags to consider satisfied during the
		build. For more information about build tags, see the description of
		build constraints in the documentation for the go/build package.
	-toolexec 'cmd args'
		a program to use to invoke toolchain programs like vet and asm.
		For example, instead of running asm, the go command will run
		'cmd args /path/to/asm <arguments for asm>'.

All the flags that take a list of arguments accept a space-separated
list of strings. To embed spaces in an element in the list, surround
it with either single or double quotes.

For more about specifying packages, see 'go help packages'.
For more about where packages and binaries are installed,
run 'go help gopath'.
For more about calling between Go and C/C++, run 'go help c'.

Note: Build adheres to certain conventions such as those described
by 'go help gopath'. Not all projects can follow these conventions,
however. Installations that have their own conventions or that use
a separate software build system may choose to use lower-level
invocations such as 'go tool compile' and 'go tool link' to avoid
some of the overheads and design decisions of the build tool.

See also: go install, go get, go clean.
View Source
var CmdInstall = &base.Command{
	UsageLine: "install [build flags] [packages]",
	Short:     "compile and install packages and dependencies",
	Long: `
Install compiles and installs the packages named by the import paths,
along with their dependencies.

For more about the build flags, see 'go help build'.
For more about specifying packages, see 'go help packages'.

See also: go build, go get, go clean.
View Source
var ExecCmd []string

ExecCmd is the command to use to run user binaries. Normally it is empty, meaning run the binaries directly. If cross-compiling and running on a remote system or simulator, it is typically go_GOOS_GOARCH_exec, with the target GOOS and GOARCH substituted. The -exec flag overrides these defaults.

View Source
var GccgoName, GccgoBin string


func AddBuildFlags

func AddBuildFlags(cmd *base.Command)

addBuildFlags adds the flags common to the build, clean, get, install, list, run, and test commands.

func BuildInstallFunc

func BuildInstallFunc(b *Builder, a *Action) (err error)

BuildInstallFunc is the action for installing a single package or executable.

func BuildModeInit

func BuildModeInit()

func FindExecCmd

func FindExecCmd() []string

FindExecCmd derives the value of ExecCmd to use. It returns that value and leaves ExecCmd set for direct use.

func InstallPackages

func InstallPackages(args []string, forGet bool)

func InstrumentInit

func InstrumentInit()


type Action

type Action struct {
	Mode       string                        // description of action operation
	Package    *load.Package                 // the package this action works on
	Deps       []*Action                     // actions that must happen before this one
	Func       func(*Builder, *Action) error // the action itself (nil = no-op)
	IgnoreFail bool                          // whether to run f even if dependencies fail
	TestOutput *bytes.Buffer                 // test output buffer
	Args       []string                      // additional args for runProgram

	// Generated files, directories.
	Link   bool   // target is executable, not just package
	Objdir string // directory for intermediate objects
	Target string // goal of the action: the created package or executable

	Failed bool // whether the action failed
	// contains filtered or unexported fields

An Action represents a single action in the action graph.

func ActionList

func ActionList(root *Action) []*Action

ActionList returns the list of actions in the dag rooted at root as visited in a depth-first post-order traversal.

type BuildMode

type BuildMode int

BuildMode specifies the build mode: are we just building things or also installing the results?

const (
	ModeBuild BuildMode = iota

type Builder

type Builder struct {
	WorkDir string // the temporary work directory (ends in filepath.Separator)

	Print func(args ...interface{}) (int, error)
	// contains filtered or unexported fields

A Builder holds global state about a build. It does not hold per-package state, because we build packages in parallel, and the builder is shared.

func (*Builder) Action

func (b *Builder) Action(mode BuildMode, depMode BuildMode, p *load.Package) *Action

Action returns the action for applying the given operation (mode) to the package. depMode is the action to use when building dependencies. action never looks for p in a shared library, but may find p's dependencies in a shared library if buildLinkshared is true.

func (*Builder) CFlags

func (b *Builder) CFlags(p *load.Package) (cppflags, cflags, cxxflags, fflags, ldflags []string)

CFlags returns the flags to use when invoking the C, C++ or Fortran compilers, or cgo.

func (*Builder) Do

func (b *Builder) Do(root *Action)

do runs the action graph rooted at root.

func (*Builder) GccCmd

func (b *Builder) GccCmd(incdir, workdir string) []string

gccCmd returns a gcc command line prefix defaultCC is defined in zdefaultcc.go, written by cmd/dist.

func (*Builder) GxxCmd

func (b *Builder) GxxCmd(incdir, workdir string) []string

gxxCmd returns a g++ command line prefix defaultCXX is defined in zdefaultcc.go, written by cmd/dist.

func (*Builder) Init

func (b *Builder) Init()

func (*Builder) Mkdir

func (b *Builder) Mkdir(dir string) error

mkdir makes the named directory.

func (*Builder) NewObjdir

func (b *Builder) NewObjdir() string

NewObjdir returns the name of a fresh object directory under b.WorkDir. It is up to the caller to call b.Mkdir on the result at an appropriate time. The result ends in a slash, so that file names in that directory can be constructed with direct string addition.

NewObjdir must be called only from a single goroutine at a time, so it is safe to call during action graph construction, but it must not be called during action graph execution.

func (*Builder) PkgconfigCmd

func (b *Builder) PkgconfigCmd() string

PkgconfigCmd returns a pkg-config binary name defaultPkgConfig is defined in zdefaultcc.go, written by cmd/dist.

func (*Builder) Showcmd

func (b *Builder) Showcmd(dir string, format string, args ...interface{})

showcmd prints the given command to standard output for the implementation of -n or -x.

Source Files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL