func targetShowCmd(cmd *cobra.Command, args []string) {
InitProject()
targetNames := []string{}
if len(args) == 0 {
for name, _ := range target.GetTargets() {
// Don't display the special unittest target; this is used
// internally by newt, so the user doesn't need to know about it.
// XXX: This is a hack; come up with a better solution for unit
// testing.
if !strings.HasSuffix(name, "/unittest") {
targetNames = append(targetNames, name)
}
}
} else {
targetSlice, err := ResolveTargets(args...)
if err != nil {
NewtUsage(cmd, err)
}
for _, t := range targetSlice {
targetNames = append(targetNames, t.FullName())
}
}
sort.Strings(targetNames)
for _, name := range targetNames {
kvPairs := map[string]string{}
util.StatusMessage(util.VERBOSITY_DEFAULT, name+"\n")
target := target.GetTargets()[name]
for k, v := range target.Vars {
kvPairs[strings.TrimPrefix(k, "target.")] = v
}
// A few variables come from the base package rather than the target.
kvPairs["syscfg"] = targetSyscfgKVToStr(
target.Package().SyscfgV.GetStringMapString("syscfg.vals"))
kvPairs["cflags"] = pkgVarSliceString(target.Package(), "pkg.cflags")
kvPairs["lflags"] = pkgVarSliceString(target.Package(), "pkg.lflags")
kvPairs["aflags"] = pkgVarSliceString(target.Package(), "pkg.aflags")
keys := []string{}
for k, _ := range kvPairs {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
val := kvPairs[k]
if len(val) > 0 {
util.StatusMessage(util.VERBOSITY_DEFAULT, " %s=%s\n",
k, kvPairs[k])
}
}
}
}
func ResolveTarget(name string) *target.Target {
// Trim trailing slash from name. This is necessary when tab
// completion is used to specify the name.
name = strings.TrimSuffix(name, "/")
targetMap := target.GetTargets()
// Check for fully-qualified name.
if t := targetMap[name]; t != nil {
return t
}
// Check the local "targets" directory.
if t := targetMap[TARGET_DEFAULT_DIR+"/"+name]; t != nil {
return t
}
// Check each repo alphabetically.
fullNames := []string{}
for fullName, _ := range targetMap {
fullNames = append(fullNames, fullName)
}
for _, fullName := range util.SortFields(fullNames...) {
if name == filepath.Base(fullName) {
return targetMap[fullName]
}
}
return nil
}
func ResolveNewTargetName(name string) (string, error) {
repoName, pkgName, err := newtutil.ParsePackageString(name)
if err != nil {
return "", err
}
if repoName != "" {
return "", util.NewNewtError("Target name cannot contain repo; " +
"must be local")
}
if pkgName == TARGET_KEYWORD_ALL {
return "", util.NewNewtError("Target name " + TARGET_KEYWORD_ALL +
" is reserved")
}
// "Naked" target names translate to "targets/<name>".
if !strings.Contains(pkgName, "/") {
pkgName = TARGET_DEFAULT_DIR + "/" + pkgName
}
if target.GetTargets()[pkgName] != nil {
return "", util.NewNewtError("Target already exists: " + pkgName)
}
return pkgName, nil
}
func (mi *MfgImage) loadTarget(targetName string) (
*target.Target, error) {
tgt := target.GetTargets()[targetName]
if tgt == nil {
return nil, mi.loadError("cannot resolve referenced target \"%s\"",
targetName)
}
return tgt, nil
}
func targetList() []string {
targetNames := []string{}
if _, err := project.TryGetProject(); err != nil {
return targetNames
}
for name, _ := range target.GetTargets() {
// Don't display the special unittest target; this is used
// internally by newt, so the user doesn't need to know about it.
// XXX: This is a hack; come up with a better solution for unit
// testing.
if !strings.HasSuffix(name, "/unittest") {
targetNames = append(targetNames,
strings.TrimPrefix(name, "targets/"))
}
}
sort.Strings(targetNames)
return targetNames
}