// @return bool true if a new dependency was detected as a
// result of satisfying an API for this
// package.
func (r *Resolver) satisfyApis(rpkg *ResolvePackage) bool {
// Assume all this package's APIs are satisfied and that no new
// dependencies will be detected.
rpkg.apisSatisfied = true
newDeps := false
features := r.cfg.FeaturesForLpkg(rpkg.LocalPackage)
// Determine if any of the package's API requirements can now be satisfied.
// If so, another full iteration is required.
reqApis := newtutil.GetStringSliceFeatures(rpkg.PkgV, features,
"pkg.req_apis")
for _, reqApi := range reqApis {
reqStatus := rpkg.reqApiMap[reqApi]
if !reqStatus {
apiSatisfied := r.satisfyReqApi(rpkg, reqApi)
if apiSatisfied {
// An API was satisfied; the package now has a new dependency
// that needs to be resolved.
newDeps = true
reqStatus = true
} else {
rpkg.reqApiMap[reqApi] = false
}
}
if reqStatus {
rpkg.apisSatisfied = false
}
}
return newDeps
}
func loadFlags(v *viper.Viper, features map[string]bool,
key string) []string {
flags := []string{}
rawFlags := newtutil.GetStringSliceFeatures(v, features, key)
for _, rawFlag := range rawFlags {
if strings.HasPrefix(rawFlag, key) {
expandedFlags := newtutil.GetStringSliceFeatures(v, features,
rawFlag)
flags = append(flags, expandedFlags...)
} else {
flags = append(flags, strings.Trim(rawFlag, "\n"))
}
}
return flags
}
// @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 (bpkg *BuildPackage) CompilerInfo(
b *Builder) (*toolchain.CompilerInfo, error) {
// If this package's compiler info has already been generated, returned the
// cached copy.
if bpkg.ci != nil {
return bpkg.ci, nil
}
ci := toolchain.NewCompilerInfo()
features := b.cfg.FeaturesForLpkg(bpkg.LocalPackage)
ci.Cflags = newtutil.GetStringSliceFeatures(bpkg.PkgV, features,
"pkg.cflags")
ci.Lflags = newtutil.GetStringSliceFeatures(bpkg.PkgV, features,
"pkg.lflags")
ci.Aflags = newtutil.GetStringSliceFeatures(bpkg.PkgV, features,
"pkg.aflags")
// Package-specific injected settings get specified as C flags on the
// command line.
for k, _ := range bpkg.InjectedSettings() {
ci.Cflags = append(ci.Cflags, syscfg.FeatureToCflag(k))
}
ci.IgnoreFiles = []*regexp.Regexp{}
ignPats := newtutil.GetStringSliceFeatures(bpkg.PkgV,
features, "pkg.ign_files")
for _, str := range ignPats {
re, err := regexp.Compile(str)
if err != nil {
return nil, util.NewNewtError(
"Ignore files, unable to compile re: " + err.Error())
}
ci.IgnoreFiles = append(ci.IgnoreFiles, re)
}
ci.IgnoreDirs = []*regexp.Regexp{}
ignPats = newtutil.GetStringSliceFeatures(bpkg.PkgV,
features, "pkg.ign_dirs")
for _, str := range ignPats {
re, err := regexp.Compile(str)
if err != nil {
return nil, util.NewNewtError(
"Ignore dirs, unable to compile re: " + err.Error())
}
ci.IgnoreDirs = append(ci.IgnoreDirs, re)
}
bpkg.SourceDirectories = newtutil.GetStringSliceFeatures(bpkg.PkgV,
features, "pkg.src_dirs")
includePaths, err := bpkg.recursiveIncludePaths(b)
if err != nil {
return nil, err
}
ci.Includes = append(bpkg.privateIncludeDirs(b), includePaths...)
bpkg.ci = ci
return bpkg.ci, nil
}