// Recursively iterates through an pkg's dependencies, adding each pkg // encountered to the supplied set. func (bpkg *BuildPackage) collectDepsAux(b *Builder, set *map[*BuildPackage]bool) error { if (*set)[bpkg] { return nil } (*set)[bpkg] = true for _, dep := range bpkg.Deps() { if dep.Name == "" { break } // Get pkg structure p := project.GetProject().ResolveDependency(dep) if p == nil { return util.FmtNewtError("Cannot resolve dependency %+v", dep) } dpkg := p.(*pkg.LocalPackage) dbpkg := b.PkgMap[dpkg] if dbpkg == nil { return util.FmtNewtError("Package not found %s; required by %s", dpkg.Name(), bpkg.Name()) } if err := dbpkg.collectDepsAux(b, set); err != nil { return err } } return nil }
func buildProfileValues() ([]string, error) { profileMap := map[string]struct{}{} packs := project.GetProject().PackagesOfType(pkg.PACKAGE_TYPE_COMPILER) for _, pack := range packs { v, err := util.ReadConfig(pack.(*pkg.LocalPackage).BasePath(), "compiler") if err != nil { return nil, err } settingMap := v.AllSettings() for k, _ := range settingMap { if strings.HasPrefix(k, "compiler.flags") { fields := strings.Split(k, ".") if len(fields) >= 3 { profileMap[fields[2]] = struct{}{} } } } } values := make([]string, 0, len(profileMap)) for k, _ := range profileMap { values = append(values, k) } sort.Strings(values) return values, nil }
func NewTargetTester(target *target.Target, testPkg *pkg.LocalPackage) (*TargetBuilder, error) { if err := target.Validate(testPkg == nil); err != nil { return nil, err } bspPkg, err := pkg.NewBspPackage(target.Bsp()) if err != nil { return nil, err } compilerPkg, err := project.GetProject().ResolvePackage( bspPkg.Repo(), bspPkg.CompilerName) if err != nil { return nil, err } t := &TargetBuilder{ target: target, bspPkg: bspPkg, compilerPkg: compilerPkg, appPkg: target.App(), loaderPkg: target.Loader(), testPkg: testPkg, injectedSettings: map[string]string{}, } return t, nil }
func (b *Builder) Debug(extraJtagCmd string, reset bool, noGDB bool) error { if b.appPkg == nil { return util.NewNewtError("app package not specified") } /* * Populate the package list and feature sets. */ err := b.targetBuilder.PrepBuild() if err != nil { return err } bspPath := b.bspPkg.BasePath() binBaseName := b.AppBinBasePath() featureString := b.FeatureString() coreRepo := project.GetProject().FindRepo("apache-mynewt-core") envSettings := []string{ fmt.Sprintf("CORE_PATH=%s", coreRepo.Path()), fmt.Sprintf("BSP_PATH=%s", bspPath), fmt.Sprintf("BIN_BASENAME=%s", binBaseName), fmt.Sprintf("FEATURES=\"%s\"", featureString), } if extraJtagCmd != "" { envSettings = append(envSettings, fmt.Sprintf("EXTRA_JTAG_CMD=%s", extraJtagCmd)) } if reset == true { envSettings = append(envSettings, fmt.Sprintf("RESET=true")) } if noGDB == true { envSettings = append(envSettings, fmt.Sprintf("NO_GDB=1")) } os.Chdir(project.GetProject().Path()) // bspPath, binBaseName are passed in command line for backwards // compatibility cmdLine := []string{ b.targetBuilder.bspPkg.DebugScript, bspPath, binBaseName, } fmt.Printf("%s\n", cmdLine) return util.ShellInteractiveCommand(cmdLine, envSettings) }
func ResetGlobalState() error { // Make sure the current working directory is at the project base. if err := os.Chdir(project.GetProject().Path()); err != nil { return util.NewNewtError("Failed to reset global state: " + err.Error()) } target.ResetTargets() project.ResetProject() return nil }
func (target *Target) resolvePackageName(name string) *pkg.LocalPackage { dep, err := pkg.NewDependency(target.basePkg.Repo(), name) if err != nil { return nil } pack, ok := project.GetProject().ResolveDependency(dep).(*pkg.LocalPackage) if !ok { return nil } return pack }
func buildTargetMap() error { globalTargetMap = map[string]*Target{} packs := project.GetProject().PackagesOfType(pkg.PACKAGE_TYPE_TARGET) for _, packItf := range packs { pack := packItf.(*pkg.LocalPackage) target, err := LoadTarget(pack) if err != nil { nerr := err.(*util.NewtError) util.ErrorMessage(util.VERBOSITY_QUIET, "Warning: failed to load target \"%s\": %s\n", pack.Name(), nerr.Text) } else { globalTargetMap[pack.FullName()] = target } } return nil }
func varsFromPackageType( pt interfaces.PackageType, fullPath bool) ([]string, error) { values := []string{} packs := project.GetProject().PackagesOfType(pt) for _, pack := range packs { value := pack.FullName() if !fullPath { value = filepath.Base(value) } values = append(values, value) } sort.Strings(values) return values, nil }
func (b *Builder) testOwner(p *BuildPackage) *BuildPackage { if p.Type() != pkg.PACKAGE_TYPE_UNITTEST { panic("Expected unittest package; got: " + p.Name()) } curPath := p.BasePath() for { parentPath := filepath.Dir(curPath) if parentPath == project.GetProject().BasePath || parentPath == "." { return nil } parentPkg := b.pkgWithPath(parentPath) if parentPkg != nil && parentPkg.Type() != pkg.PACKAGE_TYPE_UNITTEST { return parentPkg } curPath = parentPath } }
func settingValues(settingName string) ([]string, error) { settingMap := map[string]struct{}{} packs := project.GetProject().PackagesOfType(-1) for _, pack := range packs { settings := pack.(*pkg.LocalPackage).PkgV.GetStringSlice(settingName) for _, setting := range settings { settingMap[setting] = struct{}{} } } values := make([]string, 0, len(settingMap)) for f, _ := range settingMap { values = append(values, f) } sort.Strings(values) return values, nil }
func Load(binBaseName string, bspPkg *pkg.BspPackage, extraEnvSettings map[string]string) error { if bspPkg.DownloadScript == "" { return nil } bspPath := bspPkg.BasePath() sortedKeys := make([]string, 0, len(extraEnvSettings)) for k, _ := range extraEnvSettings { sortedKeys = append(sortedKeys, k) } sort.Strings(sortedKeys) envSettings := "" for _, key := range sortedKeys { envSettings += fmt.Sprintf("%s=\"%s\" ", key, extraEnvSettings[key]) } coreRepo := project.GetProject().FindRepo("apache-mynewt-core") envSettings += fmt.Sprintf("CORE_PATH=\"%s\" ", coreRepo.Path()) envSettings += fmt.Sprintf("BSP_PATH=\"%s\" ", bspPath) envSettings += fmt.Sprintf("BIN_BASENAME=\"%s\" ", binBaseName) // bspPath, binBaseName are passed in command line for backwards // compatibility downloadCmd := fmt.Sprintf("%s %s %s %s", envSettings, bspPkg.DownloadScript, bspPath, binBaseName) util.StatusMessage(util.VERBOSITY_VERBOSE, "Load command: %s\n", downloadCmd) _, err := util.ShellCommand(downloadCmd) if err != nil { return err } util.StatusMessage(util.VERBOSITY_VERBOSE, "Successfully loaded image.\n") return nil }
// @return bool True if this this function changed the builder // state; another full iteration is required // in this case. // error non-nil on failure. func (r *Resolver) loadDepsForPkg(rpkg *ResolvePackage) (bool, error) { proj := project.GetProject() features := r.cfg.FeaturesForLpkg(rpkg.LocalPackage) changed := false newDeps := newtutil.GetStringSliceFeatures(rpkg.PkgV, features, "pkg.deps") for _, newDepStr := range newDeps { newDep, err := pkg.NewDependency(rpkg.Repo(), newDepStr) if err != nil { return false, err } lpkg, ok := proj.ResolveDependency(newDep).(*pkg.LocalPackage) if !ok { return false, util.FmtNewtError("Could not resolve package dependency: "+ "%s; depender: %s", newDep.String(), rpkg.Name()) } if r.pkgMap[lpkg] == nil { changed = true r.addPkg(lpkg) } } // Determine if this package supports any APIs that we haven't seen // yet. If so, another full iteration is required. apis := newtutil.GetStringSliceFeatures(rpkg.PkgV, features, "pkg.apis") for _, api := range apis { newApi := r.addApi(api, rpkg) if newApi { changed = true } } return changed, nil }
// Resolves all of a build package's dependencies and API requirements. func (bpkg *BuildPackage) resolveDeps( cfg syscfg.Cfg, apiMap map[string]*BuildPackage) error { features := cfg.FeaturesForLpkg(bpkg.LocalPackage) // Match each required API with the package which implements it. reqApis := newtutil.GetStringSliceFeatures(bpkg.PkgV, features, "pkg.req_apis") for _, reqApi := range reqApis { if err := bpkg.satisfyReqApi(reqApi, apiMap[reqApi]); err != nil { return err } } proj := project.GetProject() newDeps := newtutil.GetStringSliceFeatures(bpkg.PkgV, features, "pkg.deps") for _, newDepStr := range newDeps { newDep, err := pkg.NewDependency(bpkg.Repo(), newDepStr) if err != nil { return err } _, ok := proj.ResolveDependency(newDep).(*pkg.LocalPackage) if !ok { return util.NewNewtError("Could not resolve package dependency " + newDep.String()) } if !bpkg.HasDep(newDep) { bpkg.AddDep(newDep) } } return nil }
func BinRoot() string { return project.GetProject().Path() + "/bin" }
func Load(basePkg *pkg.LocalPackage) (*MfgImage, error) { v, err := util.ReadConfig(basePkg.BasePath(), strings.TrimSuffix(MFG_YAML_FILENAME, ".yml")) if err != nil { return nil, err } mi := &MfgImage{ basePkg: basePkg, } bootName := v.GetString("mfg.bootloader") if bootName == "" { return nil, mi.loadError("mfg.bootloader field required") } mi.boot, err = mi.loadTarget(bootName) if err != nil { return nil, err } imgNames := v.GetStringSlice("mfg.images") if imgNames != nil { for _, imgName := range imgNames { imgTarget, err := mi.loadTarget(imgName) if err != nil { return nil, err } mi.images = append(mi.images, imgTarget) } } if len(mi.images) > 2 { return nil, mi.loadError("too many images (%d); maximum is 2", len(mi.images)) } itf := v.Get("mfg.raw") slice := cast.ToSlice(itf) if slice != nil { for i, entryItf := range slice { yamlEntry := cast.ToStringMapString(entryItf) entry, err := mi.loadRawEntry(i, yamlEntry) if err != nil { return nil, err } mi.rawEntries = append(mi.rawEntries, entry) } } proj := project.GetProject() bspLpkg, err := proj.ResolvePackage(mi.basePkg.Repo(), mi.boot.BspName) if err != nil { return nil, mi.loadError( "could not resolve boot loader BSP package: %s", mi.boot.BspName) } mi.bsp, err = pkg.NewBspPackage(bspLpkg) if err != nil { return nil, mi.loadError(err.Error()) } for _, imgTarget := range mi.images { if len(mi.images) > 1 && imgTarget.LoaderName != "" { return nil, mi.loadError("only one image allowed in "+ "split image mode (%s is a split build)", imgTarget.Name()) } if imgTarget.Bsp() != mi.bsp.LocalPackage { return nil, mi.loadError( "image target \"%s\" specified conflicting BSP; "+ "boot loader uses %s, image uses %s", imgTarget.Name(), mi.bsp.Name(), imgTarget.BspName) } } if err := mi.detectInvalidDevices(); err != nil { return nil, err } return mi, nil }