// TargetSpecificDirname returns a directory name that is specific
// to that target taking account the architecture, operating system and
// command line environment variables, if relevant, into account (e.g
// GOARM={5,6,7}).
func (pt *Target) TargetSpecificDirname() string {
env := envvar.SliceToMap(pt.commandLineEnv.Vars)
dir := pt.arch + "_" + pt.opsys
if pt.arch == "arm" {
if armv, present := env["GOARM"]; present {
dir += "_armv" + armv
}
}
return dir
}
// GoEnvironmentFromOS() returns the values of all Go environment variables
// as set via the OS; unset variables are omitted.
func GoEnvironmentFromOS() []string {
os := envvar.SliceToMap(os.Environ())
vars := make([]string, 0, len(GoFlags))
for _, k := range GoFlags {
v, present := os[k]
if !present {
continue
}
vars = append(vars, envvar.JoinKeyValue(k, v))
}
return vars
}
// NewSequence creates an instance of Sequence with default values for its
// environment, stdin, stderr, stdout and other supported options.
// If the environment parameter is nil or empty then the current value of
// os.Environ() will be used instead.
func NewSequence(env map[string]string, stdin io.Reader, stdout, stderr io.Writer, color, verbose bool) Sequence {
if len(env) == 0 {
env = envvar.SliceToMap(os.Environ())
}
s := Sequence{
&sequence{
r: newExecutor(env, stdin, stdout, stderr, color, verbose),
defaultStdin: stdin,
},
}
s.defaultStdout, s.defaultStderr = s.serializeWriter(stdout), s.serializeWriter(stderr)
return s
}
func runEnv(env *cmdline.Env, args []string) error {
if len(profileFlag) == 0 {
return fmt.Errorf("no profile was specified using --profile")
}
ctx := tool.NewContextFromEnv(env)
if err := profiles.Read(ctx, manifestFlag); err != nil {
return fmt.Errorf("Failed to read manifest: %v", err)
}
profile := profiles.LookupProfile(profileFlag)
if profile == nil {
return fmt.Errorf("profile %q is not installed", profileFlag)
}
target := profiles.FindTarget(profile.Targets(), &targetFlag)
if target == nil {
return fmt.Errorf("target %q is not installed for profile %q", targetFlag, profileFlag)
}
vars := envvar.SliceToMap(target.Env.Vars)
buf := bytes.Buffer{}
if len(args) == 0 {
for k, v := range vars {
buf.WriteString(fmt.Sprintf("%s=%q ", k, v))
}
for k, fn := range pseudoVariables {
buf.WriteString(fmt.Sprintf("%s=%q ", k, fn(target)))
}
} else {
for _, arg := range args {
name := strings.TrimSuffix(arg, "=")
trimmed := name != arg
for k, fn := range pseudoVariables {
if k == name {
buf.WriteString(expr(k, fn(target), trimmed))
}
}
for k, v := range vars {
if k == name {
buf.WriteString(expr(k, v, trimmed))
}
}
}
}
fmt.Fprintf(ctx.Stdout(), strings.TrimSuffix(buf.String(), " ")+"\n")
return nil
}
