blob: eaa6a8d0b41fe11988517679a868bcc63a8a3f0e [file] [log] [blame]
// Copyright 2015 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package android
import (
"fmt"
"os"
"path/filepath"
"reflect"
"regexp"
"sort"
"strings"
"github.com/google/blueprint"
"github.com/google/blueprint/bootstrap"
"github.com/google/blueprint/pathtools"
)
var absSrcDir string
// PathContext is the subset of a (Module|Singleton)Context required by the
// Path methods.
type PathContext interface {
Config() Config
AddNinjaFileDeps(deps ...string)
}
type PathGlobContext interface {
PathContext
GlobWithDeps(globPattern string, excludes []string) ([]string, error)
}
var _ PathContext = SingletonContext(nil)
var _ PathContext = ModuleContext(nil)
// "Null" path context is a minimal path context for a given config.
type NullPathContext struct {
config Config
}
func (NullPathContext) AddNinjaFileDeps(...string) {}
func (ctx NullPathContext) Config() Config { return ctx.config }
// EarlyModulePathContext is a subset of EarlyModuleContext methods required by the
// Path methods. These path methods can be called before any mutators have run.
type EarlyModulePathContext interface {
PathGlobContext
ModuleDir() string
ModuleErrorf(fmt string, args ...interface{})
}
var _ EarlyModulePathContext = ModuleContext(nil)
// Glob globs files and directories matching globPattern relative to ModuleDir(),
// paths in the excludes parameter will be omitted.
func Glob(ctx EarlyModulePathContext, globPattern string, excludes []string) Paths {
ret, err := ctx.GlobWithDeps(globPattern, excludes)
if err != nil {
ctx.ModuleErrorf("glob: %s", err.Error())
}
return pathsForModuleSrcFromFullPath(ctx, ret, true)
}
// GlobFiles globs *only* files (not directories) matching globPattern relative to ModuleDir().
// Paths in the excludes parameter will be omitted.
func GlobFiles(ctx EarlyModulePathContext, globPattern string, excludes []string) Paths {
ret, err := ctx.GlobWithDeps(globPattern, excludes)
if err != nil {
ctx.ModuleErrorf("glob: %s", err.Error())
}
return pathsForModuleSrcFromFullPath(ctx, ret, false)
}
// ModuleWithDepsPathContext is a subset of *ModuleContext methods required by
// the Path methods that rely on module dependencies having been resolved.
type ModuleWithDepsPathContext interface {
EarlyModulePathContext
VisitDirectDepsBlueprint(visit func(blueprint.Module))
OtherModuleDependencyTag(m blueprint.Module) blueprint.DependencyTag
}
// ModuleMissingDepsPathContext is a subset of *ModuleContext methods required by
// the Path methods that rely on module dependencies having been resolved and ability to report
// missing dependency errors.
type ModuleMissingDepsPathContext interface {
ModuleWithDepsPathContext
AddMissingDependencies(missingDeps []string)
}
type ModuleInstallPathContext interface {
BaseModuleContext
InstallInData() bool
InstallInTestcases() bool
InstallInSanitizerDir() bool
InstallInRamdisk() bool
InstallInVendorRamdisk() bool
InstallInDebugRamdisk() bool
InstallInRecovery() bool
InstallInRoot() bool
InstallForceOS() (*OsType, *ArchType)
}
var _ ModuleInstallPathContext = ModuleContext(nil)
// errorfContext is the interface containing the Errorf method matching the
// Errorf method in blueprint.SingletonContext.
type errorfContext interface {
Errorf(format string, args ...interface{})
}
var _ errorfContext = blueprint.SingletonContext(nil)
// moduleErrorf is the interface containing the ModuleErrorf method matching
// the ModuleErrorf method in blueprint.ModuleContext.
type moduleErrorf interface {
ModuleErrorf(format string, args ...interface{})
}
var _ moduleErrorf = blueprint.ModuleContext(nil)
// reportPathError will register an error with the attached context. It
// attempts ctx.ModuleErrorf for a better error message first, then falls
// back to ctx.Errorf.
func reportPathError(ctx PathContext, err error) {
ReportPathErrorf(ctx, "%s", err.Error())
}
// ReportPathErrorf will register an error with the attached context. It
// attempts ctx.ModuleErrorf for a better error message first, then falls
// back to ctx.Errorf.
func ReportPathErrorf(ctx PathContext, format string, args ...interface{}) {
if mctx, ok := ctx.(moduleErrorf); ok {
mctx.ModuleErrorf(format, args...)
} else if ectx, ok := ctx.(errorfContext); ok {
ectx.Errorf(format, args...)
} else {
panic(fmt.Sprintf(format, args...))
}
}
func pathContextName(ctx PathContext, module blueprint.Module) string {
if x, ok := ctx.(interface{ ModuleName(blueprint.Module) string }); ok {
return x.ModuleName(module)
} else if x, ok := ctx.(interface{ OtherModuleName(blueprint.Module) string }); ok {
return x.OtherModuleName(module)
}
return "unknown"
}
type Path interface {
// Returns the path in string form
String() string
// Ext returns the extension of the last element of the path
Ext() string
// Base returns the last element of the path
Base() string
// Rel returns the portion of the path relative to the directory it was created from. For
// example, Rel on a PathsForModuleSrc would return the path relative to the module source
// directory, and OutputPath.Join("foo").Rel() would return "foo".
Rel() string
// RelativeToTop returns a new path relative to the top, it is provided solely for use in tests.
//
// It is guaranteed to always return the same type as it is called on, e.g. if called on an
// InstallPath then the returned value can be converted to an InstallPath.
//
// A standard build has the following structure:
// ../top/
// out/ - make install files go here.
// out/soong - this is the soongOutDir passed to NewTestConfig()
// ... - the source files
//
// This function converts a path so that it appears relative to the ../top/ directory, i.e.
// * Make install paths, which have the pattern "soongOutDir/../<path>" are converted into the top
// relative path "out/<path>"
// * Soong install paths and other writable paths, which have the pattern "soongOutDir/<path>" are
// converted into the top relative path "out/soong/<path>".
// * Source paths are already relative to the top.
// * Phony paths are not relative to anything.
// * toolDepPath have an absolute but known value in so don't need making relative to anything in
// order to test.
RelativeToTop() Path
}
const (
OutDir = "out"
OutSoongDir = OutDir + "/soong"
)
// WritablePath is a type of path that can be used as an output for build rules.
type WritablePath interface {
Path
// return the path to the build directory.
getSoongOutDir() string
// the writablePath method doesn't directly do anything,
// but it allows a struct to distinguish between whether or not it implements the WritablePath interface
writablePath()
ReplaceExtension(ctx PathContext, ext string) OutputPath
}
type genPathProvider interface {
genPathWithExt(ctx ModuleOutPathContext, subdir, ext string) ModuleGenPath
}
type objPathProvider interface {
objPathWithExt(ctx ModuleOutPathContext, subdir, ext string) ModuleObjPath
}
type resPathProvider interface {
resPathWithName(ctx ModuleOutPathContext, name string) ModuleResPath
}
// GenPathWithExt derives a new file path in ctx's generated sources directory
// from the current path, but with the new extension.
func GenPathWithExt(ctx ModuleOutPathContext, subdir string, p Path, ext string) ModuleGenPath {
if path, ok := p.(genPathProvider); ok {
return path.genPathWithExt(ctx, subdir, ext)
}
ReportPathErrorf(ctx, "Tried to create generated file from unsupported path: %s(%s)", reflect.TypeOf(p).Name(), p)
return PathForModuleGen(ctx)
}
// ObjPathWithExt derives a new file path in ctx's object directory from the
// current path, but with the new extension.
func ObjPathWithExt(ctx ModuleOutPathContext, subdir string, p Path, ext string) ModuleObjPath {
if path, ok := p.(objPathProvider); ok {
return path.objPathWithExt(ctx, subdir, ext)
}
ReportPathErrorf(ctx, "Tried to create object file from unsupported path: %s (%s)", reflect.TypeOf(p).Name(), p)
return PathForModuleObj(ctx)
}
// ResPathWithName derives a new path in ctx's output resource directory, using
// the current path to create the directory name, and the `name` argument for
// the filename.
func ResPathWithName(ctx ModuleOutPathContext, p Path, name string) ModuleResPath {
if path, ok := p.(resPathProvider); ok {
return path.resPathWithName(ctx, name)
}
ReportPathErrorf(ctx, "Tried to create res file from unsupported path: %s (%s)", reflect.TypeOf(p).Name(), p)
return PathForModuleRes(ctx)
}
// OptionalPath is a container that may or may not contain a valid Path.
type OptionalPath struct {
path Path // nil if invalid.
invalidReason string // Not applicable if path != nil. "" if the reason is unknown.
}
// OptionalPathForPath returns an OptionalPath containing the path.
func OptionalPathForPath(path Path) OptionalPath {
return OptionalPath{path: path}
}
// InvalidOptionalPath returns an OptionalPath that is invalid with the given reason.
func InvalidOptionalPath(reason string) OptionalPath {
return OptionalPath{invalidReason: reason}
}
// Valid returns whether there is a valid path
func (p OptionalPath) Valid() bool {
return p.path != nil
}
// Path returns the Path embedded in this OptionalPath. You must be sure that
// there is a valid path, since this method will panic if there is not.
func (p OptionalPath) Path() Path {
if p.path == nil {
msg := "Requesting an invalid path"
if p.invalidReason != "" {
msg += ": " + p.invalidReason
}
panic(msg)
}
return p.path
}
// InvalidReason returns the reason that the optional path is invalid, or "" if it is valid.
func (p OptionalPath) InvalidReason() string {
if p.path != nil {
return ""
}
if p.invalidReason == "" {
return "unknown"
}
return p.invalidReason
}
// AsPaths converts the OptionalPath into Paths.
//
// It returns nil if this is not valid, or a single length slice containing the Path embedded in
// this OptionalPath.
func (p OptionalPath) AsPaths() Paths {
if p.path == nil {
return nil
}
return Paths{p.path}
}
// RelativeToTop returns an OptionalPath with the path that was embedded having been replaced by the
// result of calling Path.RelativeToTop on it.
func (p OptionalPath) RelativeToTop() OptionalPath {
if p.path == nil {
return p
}
p.path = p.path.RelativeToTop()
return p
}
// String returns the string version of the Path, or "" if it isn't valid.
func (p OptionalPath) String() string {
if p.path != nil {
return p.path.String()
} else {
return ""
}
}
// Paths is a slice of Path objects, with helpers to operate on the collection.
type Paths []Path
// RelativeToTop creates a new Paths containing the result of calling Path.RelativeToTop on each
// item in this slice.
func (p Paths) RelativeToTop() Paths {
ensureTestOnly()
if p == nil {
return p
}
ret := make(Paths, len(p))
for i, path := range p {
ret[i] = path.RelativeToTop()
}
return ret
}
func (paths Paths) containsPath(path Path) bool {
for _, p := range paths {
if p == path {
return true
}
}
return false
}
// PathsForSource returns Paths rooted from SrcDir, *not* rooted from the module's local source
// directory
func PathsForSource(ctx PathContext, paths []string) Paths {
ret := make(Paths, len(paths))
for i, path := range paths {
ret[i] = PathForSource(ctx, path)
}
return ret
}
// ExistentPathsForSources returns a list of Paths rooted from SrcDir, *not* rooted from the
// module's local source directory, that are found in the tree. If any are not found, they are
// omitted from the list, and dependencies are added so that we're re-run when they are added.
func ExistentPathsForSources(ctx PathGlobContext, paths []string) Paths {
ret := make(Paths, 0, len(paths))
for _, path := range paths {
p := ExistentPathForSource(ctx, path)
if p.Valid() {
ret = append(ret, p.Path())
}
}
return ret
}
// PathsForModuleSrc returns a Paths{} containing the resolved references in paths:
// - filepath, relative to local module directory, resolves as a filepath relative to the local
// source directory
// - glob, relative to the local module directory, resolves as filepath(s), relative to the local
// source directory.
// - other modules using the ":name{.tag}" syntax. These modules must implement SourceFileProducer
// or OutputFileProducer. These resolve as a filepath to an output filepath or generated source
// filepath.
//
// Properties passed as the paths argument must have been annotated with struct tag
// `android:"path"` so that dependencies on SourceFileProducer modules will have already been handled by the
// path_deps mutator.
// If a requested module is not found as a dependency:
// - if ctx.Config().AllowMissingDependencies() is true, this module to be marked as having
// missing dependencies
// - otherwise, a ModuleError is thrown.
func PathsForModuleSrc(ctx ModuleMissingDepsPathContext, paths []string) Paths {
return PathsForModuleSrcExcludes(ctx, paths, nil)
}
type SourceInput struct {
Context ModuleMissingDepsPathContext
Paths []string
ExcludePaths []string
IncludeDirs bool
}
// PathsForModuleSrcExcludes returns a Paths{} containing the resolved references in paths, minus
// those listed in excludes. Elements of paths and excludes are resolved as:
// - filepath, relative to local module directory, resolves as a filepath relative to the local
// source directory
// - glob, relative to the local module directory, resolves as filepath(s), relative to the local
// source directory. Not valid in excludes.
// - other modules using the ":name{.tag}" syntax. These modules must implement SourceFileProducer
// or OutputFileProducer. These resolve as a filepath to an output filepath or generated source
// filepath.
//
// excluding the items (similarly resolved
// Properties passed as the paths argument must have been annotated with struct tag
// `android:"path"` so that dependencies on SourceFileProducer modules will have already been handled by the
// path_deps mutator.
// If a requested module is not found as a dependency:
// - if ctx.Config().AllowMissingDependencies() is true, this module to be marked as having
// missing dependencies
// - otherwise, a ModuleError is thrown.
func PathsForModuleSrcExcludes(ctx ModuleMissingDepsPathContext, paths, excludes []string) Paths {
return PathsRelativeToModuleSourceDir(SourceInput{
Context: ctx,
Paths: paths,
ExcludePaths: excludes,
IncludeDirs: true,
})
}
func PathsRelativeToModuleSourceDir(input SourceInput) Paths {
ret, missingDeps := PathsAndMissingDepsRelativeToModuleSourceDir(input)
if input.Context.Config().AllowMissingDependencies() {
input.Context.AddMissingDependencies(missingDeps)
} else {
for _, m := range missingDeps {
input.Context.ModuleErrorf(`missing dependency on %q, is the property annotated with android:"path"?`, m)
}
}
return ret
}
// OutputPaths is a slice of OutputPath objects, with helpers to operate on the collection.
type OutputPaths []OutputPath
// Paths returns the OutputPaths as a Paths
func (p OutputPaths) Paths() Paths {
if p == nil {
return nil
}
ret := make(Paths, len(p))
for i, path := range p {
ret[i] = path
}
return ret
}
// Strings returns the string forms of the writable paths.
func (p OutputPaths) Strings() []string {
if p == nil {
return nil
}
ret := make([]string, len(p))
for i, path := range p {
ret[i] = path.String()
}
return ret
}
// PathForGoBinary returns the path to the installed location of a bootstrap_go_binary module.
func PathForGoBinary(ctx PathContext, goBinary bootstrap.GoBinaryTool) Path {
goBinaryInstallDir := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "bin", false)
rel := Rel(ctx, goBinaryInstallDir.String(), goBinary.InstallPath())
return goBinaryInstallDir.Join(ctx, rel)
}
// Expands Paths to a SourceFileProducer or OutputFileProducer module dependency referenced via ":name" or ":name{.tag}" syntax.
// If the dependency is not found, a missingErrorDependency is returned.
// If the module dependency is not a SourceFileProducer or OutputFileProducer, appropriate errors will be returned.
func getPathsFromModuleDep(ctx ModuleWithDepsPathContext, path, moduleName, tag string) (Paths, error) {
module := GetModuleFromPathDep(ctx, moduleName, tag)
if module == nil {
return nil, missingDependencyError{[]string{moduleName}}
}
if aModule, ok := module.(Module); ok && !aModule.Enabled() {
return nil, missingDependencyError{[]string{moduleName}}
}
if outProducer, ok := module.(OutputFileProducer); ok {
outputFiles, err := outProducer.OutputFiles(tag)
if err != nil {
return nil, fmt.Errorf("path dependency %q: %s", path, err)
}
return outputFiles, nil
} else if tag != "" {
return nil, fmt.Errorf("path dependency %q is not an output file producing module", path)
} else if goBinary, ok := module.(bootstrap.GoBinaryTool); ok {
goBinaryPath := PathForGoBinary(ctx, goBinary)
return Paths{goBinaryPath}, nil
} else if srcProducer, ok := module.(SourceFileProducer); ok {
return srcProducer.Srcs(), nil
} else {
return nil, fmt.Errorf("path dependency %q is not a source file producing module", path)
}
}
// GetModuleFromPathDep will return the module that was added as a dependency automatically for
// properties tagged with `android:"path"` or manually using ExtractSourceDeps or
// ExtractSourcesDeps.
//
// The moduleName and tag supplied to this should be the values returned from SrcIsModuleWithTag.
// Or, if no tag is expected then the moduleName should be the value returned by SrcIsModule and
// the tag must be "".
//
// If tag is "" then the returned module will be the dependency that was added for ":moduleName".
// Otherwise, it is the dependency that was added for ":moduleName{tag}".
func GetModuleFromPathDep(ctx ModuleWithDepsPathContext, moduleName, tag string) blueprint.Module {
var found blueprint.Module
// The sourceOrOutputDepTag uniquely identifies the module dependency as it contains both the
// module name and the tag. Dependencies added automatically for properties tagged with
// `android:"path"` are deduped so are guaranteed to be unique. It is possible for duplicate
// dependencies to be added manually using ExtractSourcesDeps or ExtractSourceDeps but even then
// it will always be the case that the dependencies will be identical, i.e. the same tag and same
// moduleName referring to the same dependency module.
//
// It does not matter whether the moduleName is a fully qualified name or if the module
// dependency is a prebuilt module. All that matters is the same information is supplied to
// create the tag here as was supplied to create the tag when the dependency was added so that
// this finds the matching dependency module.
expectedTag := sourceOrOutputDepTag(moduleName, tag)
ctx.VisitDirectDepsBlueprint(func(module blueprint.Module) {
depTag := ctx.OtherModuleDependencyTag(module)
if depTag == expectedTag {
found = module
}
})
return found
}
// PathsAndMissingDepsForModuleSrcExcludes returns a Paths{} containing the resolved references in
// paths, minus those listed in excludes. Elements of paths and excludes are resolved as:
// - filepath, relative to local module directory, resolves as a filepath relative to the local
// source directory
// - glob, relative to the local module directory, resolves as filepath(s), relative to the local
// source directory. Not valid in excludes.
// - other modules using the ":name{.tag}" syntax. These modules must implement SourceFileProducer
// or OutputFileProducer. These resolve as a filepath to an output filepath or generated source
// filepath.
//
// and a list of the module names of missing module dependencies are returned as the second return.
// Properties passed as the paths argument must have been annotated with struct tag
// `android:"path"` so that dependencies on SourceFileProducer modules will have already been handled by the
// path_deps mutator.
func PathsAndMissingDepsForModuleSrcExcludes(ctx ModuleMissingDepsPathContext, paths, excludes []string) (Paths, []string) {
return PathsAndMissingDepsRelativeToModuleSourceDir(SourceInput{
Context: ctx,
Paths: paths,
ExcludePaths: excludes,
IncludeDirs: true,
})
}
func PathsAndMissingDepsRelativeToModuleSourceDir(input SourceInput) (Paths, []string) {
prefix := pathForModuleSrc(input.Context).String()
var expandedExcludes []string
if input.ExcludePaths != nil {
expandedExcludes = make([]string, 0, len(input.ExcludePaths))
}
var missingExcludeDeps []string
for _, e := range input.ExcludePaths {
if m, t := SrcIsModuleWithTag(e); m != "" {
modulePaths, err := getPathsFromModuleDep(input.Context, e, m, t)
if m, ok := err.(missingDependencyError); ok {
missingExcludeDeps = append(missingExcludeDeps, m.missingDeps...)
} else if err != nil {
reportPathError(input.Context, err)
} else {
expandedExcludes = append(expandedExcludes, modulePaths.Strings()...)
}
} else {
expandedExcludes = append(expandedExcludes, filepath.Join(prefix, e))
}
}
if input.Paths == nil {
return nil, missingExcludeDeps
}
var missingDeps []string
expandedSrcFiles := make(Paths, 0, len(input.Paths))
for _, s := range input.Paths {
srcFiles, err := expandOneSrcPath(sourcePathInput{
context: input.Context,
path: s,
expandedExcludes: expandedExcludes,
includeDirs: input.IncludeDirs,
})
if depErr, ok := err.(missingDependencyError); ok {
missingDeps = append(missingDeps, depErr.missingDeps...)
} else if err != nil {
reportPathError(input.Context, err)
}
expandedSrcFiles = append(expandedSrcFiles, srcFiles...)
}
return expandedSrcFiles, append(missingDeps, missingExcludeDeps...)
}
type missingDependencyError struct {
missingDeps []string
}
func (e missingDependencyError) Error() string {
return "missing dependencies: " + strings.Join(e.missingDeps, ", ")
}
type sourcePathInput struct {
context ModuleWithDepsPathContext
path string
expandedExcludes []string
includeDirs bool
}
// Expands one path string to Paths rooted from the module's local source
// directory, excluding those listed in the expandedExcludes.
// Expands globs, references to SourceFileProducer or OutputFileProducer modules using the ":name" and ":name{.tag}" syntax.
func expandOneSrcPath(input sourcePathInput) (Paths, error) {
excludePaths := func(paths Paths) Paths {
if len(input.expandedExcludes) == 0 {
return paths
}
remainder := make(Paths, 0, len(paths))
for _, p := range paths {
if !InList(p.String(), input.expandedExcludes) {
remainder = append(remainder, p)
}
}
return remainder
}
if m, t := SrcIsModuleWithTag(input.path); m != "" {
modulePaths, err := getPathsFromModuleDep(input.context, input.path, m, t)
if err != nil {
return nil, err
} else {
return excludePaths(modulePaths), nil
}
} else {
p := pathForModuleSrc(input.context, input.path)
if pathtools.IsGlob(input.path) {
paths := GlobFiles(input.context, p.String(), input.expandedExcludes)
return PathsWithModuleSrcSubDir(input.context, paths, ""), nil
} else {
if exists, _, err := input.context.Config().fs.Exists(p.String()); err != nil {
ReportPathErrorf(input.context, "%s: %s", p, err.Error())
} else if !exists && !input.context.Config().TestAllowNonExistentPaths {
ReportPathErrorf(input.context, "module source path %q does not exist", p)
} else if !input.includeDirs {
if isDir, err := input.context.Config().fs.IsDir(p.String()); exists && err != nil {
ReportPathErrorf(input.context, "%s: %s", p, err.Error())
} else if isDir {
ReportPathErrorf(input.context, "module source path %q is a directory", p)
}
}
if InList(p.String(), input.expandedExcludes) {
return nil, nil
}
return Paths{p}, nil
}
}
}
// pathsForModuleSrcFromFullPath returns Paths rooted from the module's local
// source directory, but strip the local source directory from the beginning of
// each string. If incDirs is false, strip paths with a trailing '/' from the list.
// It intended for use in globs that only list files that exist, so it allows '$' in
// filenames.
func pathsForModuleSrcFromFullPath(ctx EarlyModulePathContext, paths []string, incDirs bool) Paths {
prefix := ctx.ModuleDir() + "/"
if prefix == "./" {
prefix = ""
}
ret := make(Paths, 0, len(paths))
for _, p := range paths {
if !incDirs && strings.HasSuffix(p, "/") {
continue
}
path := filepath.Clean(p)
if !strings.HasPrefix(path, prefix) {
ReportPathErrorf(ctx, "Path %q is not in module source directory %q", p, prefix)
continue
}
srcPath, err := safePathForSource(ctx, ctx.ModuleDir(), path[len(prefix):])
if err != nil {
reportPathError(ctx, err)
continue
}
srcPath.basePath.rel = srcPath.path
ret = append(ret, srcPath)
}
return ret
}
// PathsWithOptionalDefaultForModuleSrc returns Paths rooted from the module's local source
// directory. If input is nil, use the default if it exists. If input is empty, returns nil.
func PathsWithOptionalDefaultForModuleSrc(ctx ModuleMissingDepsPathContext, input []string, def string) Paths {
if input != nil {
return PathsForModuleSrc(ctx, input)
}
// Use Glob so that if the default doesn't exist, a dependency is added so that when it
// is created, we're run again.
path := filepath.Join(ctx.ModuleDir(), def)
return Glob(ctx, path, nil)
}
// Strings returns the Paths in string form
func (p Paths) Strings() []string {
if p == nil {
return nil
}
ret := make([]string, len(p))
for i, path := range p {
ret[i] = path.String()
}
return ret
}
func CopyOfPaths(paths Paths) Paths {
return append(Paths(nil), paths...)
}
// FirstUniquePaths returns all unique elements of a Paths, keeping the first copy of each. It
// modifies the Paths slice contents in place, and returns a subslice of the original slice.
func FirstUniquePaths(list Paths) Paths {
// 128 was chosen based on BenchmarkFirstUniquePaths results.
if len(list) > 128 {
return firstUniquePathsMap(list)
}
return firstUniquePathsList(list)
}
// SortedUniquePaths returns all unique elements of a Paths in sorted order. It modifies the
// Paths slice contents in place, and returns a subslice of the original slice.
func SortedUniquePaths(list Paths) Paths {
unique := FirstUniquePaths(list)
sort.Slice(unique, func(i, j int) bool {
return unique[i].String() < unique[j].String()
})
return unique
}
func firstUniquePathsList(list Paths) Paths {
k := 0
outer:
for i := 0; i < len(list); i++ {
for j := 0; j < k; j++ {
if list[i] == list[j] {
continue outer
}
}
list[k] = list[i]
k++
}
return list[:k]
}
func firstUniquePathsMap(list Paths) Paths {
k := 0
seen := make(map[Path]bool, len(list))
for i := 0; i < len(list); i++ {
if seen[list[i]] {
continue
}
seen[list[i]] = true
list[k] = list[i]
k++
}
return list[:k]
}
// FirstUniqueInstallPaths returns all unique elements of an InstallPaths, keeping the first copy of each. It
// modifies the InstallPaths slice contents in place, and returns a subslice of the original slice.
func FirstUniqueInstallPaths(list InstallPaths) InstallPaths {
// 128 was chosen based on BenchmarkFirstUniquePaths results.
if len(list) > 128 {
return firstUniqueInstallPathsMap(list)
}
return firstUniqueInstallPathsList(list)
}
func firstUniqueInstallPathsList(list InstallPaths) InstallPaths {
k := 0
outer:
for i := 0; i < len(list); i++ {
for j := 0; j < k; j++ {
if list[i] == list[j] {
continue outer
}
}
list[k] = list[i]
k++
}
return list[:k]
}
func firstUniqueInstallPathsMap(list InstallPaths) InstallPaths {
k := 0
seen := make(map[InstallPath]bool, len(list))
for i := 0; i < len(list); i++ {
if seen[list[i]] {
continue
}
seen[list[i]] = true
list[k] = list[i]
k++
}
return list[:k]
}
// LastUniquePaths returns all unique elements of a Paths, keeping the last copy of each. It
// modifies the Paths slice contents in place, and returns a subslice of the original slice.
func LastUniquePaths(list Paths) Paths {
totalSkip := 0
for i := len(list) - 1; i >= totalSkip; i-- {
skip := 0
for j := i - 1; j >= totalSkip; j-- {
if list[i] == list[j] {
skip++
} else {
list[j+skip] = list[j]
}
}
totalSkip += skip
}
return list[totalSkip:]
}
// ReversePaths returns a copy of a Paths in reverse order.
func ReversePaths(list Paths) Paths {
if list == nil {
return nil
}
ret := make(Paths, len(list))
for i := range list {
ret[i] = list[len(list)-1-i]
}
return ret
}
func indexPathList(s Path, list []Path) int {
for i, l := range list {
if l == s {
return i
}
}
return -1
}
func inPathList(p Path, list []Path) bool {
return indexPathList(p, list) != -1
}
func FilterPathList(list []Path, filter []Path) (remainder []Path, filtered []Path) {
return FilterPathListPredicate(list, func(p Path) bool { return inPathList(p, filter) })
}
func FilterPathListPredicate(list []Path, predicate func(Path) bool) (remainder []Path, filtered []Path) {
for _, l := range list {
if predicate(l) {
filtered = append(filtered, l)
} else {
remainder = append(remainder, l)
}
}
return
}
// HasExt returns true of any of the paths have extension ext, otherwise false
func (p Paths) HasExt(ext string) bool {
for _, path := range p {
if path.Ext() == ext {
return true
}
}
return false
}
// FilterByExt returns the subset of the paths that have extension ext
func (p Paths) FilterByExt(ext string) Paths {
ret := make(Paths, 0, len(p))
for _, path := range p {
if path.Ext() == ext {
ret = append(ret, path)
}
}
return ret
}
// FilterOutByExt returns the subset of the paths that do not have extension ext
func (p Paths) FilterOutByExt(ext string) Paths {
ret := make(Paths, 0, len(p))
for _, path := range p {
if path.Ext() != ext {
ret = append(ret, path)
}
}
return ret
}
// DirectorySortedPaths is a slice of paths that are sorted such that all files in a directory
// (including subdirectories) are in a contiguous subslice of the list, and can be found in
// O(log(N)) time using a binary search on the directory prefix.
type DirectorySortedPaths Paths
func PathsToDirectorySortedPaths(paths Paths) DirectorySortedPaths {
ret := append(DirectorySortedPaths(nil), paths...)
sort.Slice(ret, func(i, j int) bool {
return ret[i].String() < ret[j].String()
})
return ret
}
// PathsInDirectory returns a subslice of the DirectorySortedPaths as a Paths that contains all entries
// that are in the specified directory and its subdirectories.
func (p DirectorySortedPaths) PathsInDirectory(dir string) Paths {
prefix := filepath.Clean(dir) + "/"
start := sort.Search(len(p), func(i int) bool {
return prefix < p[i].String()
})
ret := p[start:]
end := sort.Search(len(ret), func(i int) bool {
return !strings.HasPrefix(ret[i].String(), prefix)
})
ret = ret[:end]
return Paths(ret)
}
// WritablePaths is a slice of WritablePath, used for multiple outputs.
type WritablePaths []WritablePath
// RelativeToTop creates a new WritablePaths containing the result of calling Path.RelativeToTop on
// each item in this slice.
func (p WritablePaths) RelativeToTop() WritablePaths {
ensureTestOnly()
if p == nil {
return p
}
ret := make(WritablePaths, len(p))
for i, path := range p {
ret[i] = path.RelativeToTop().(WritablePath)
}
return ret
}
// Strings returns the string forms of the writable paths.
func (p WritablePaths) Strings() []string {
if p == nil {
return nil
}
ret := make([]string, len(p))
for i, path := range p {
ret[i] = path.String()
}
return ret
}
// Paths returns the WritablePaths as a Paths
func (p WritablePaths) Paths() Paths {
if p == nil {
return nil
}
ret := make(Paths, len(p))
for i, path := range p {
ret[i] = path
}
return ret
}
type basePath struct {
path string
rel string
}
func (p basePath) Ext() string {
return filepath.Ext(p.path)
}
func (p basePath) Base() string {
return filepath.Base(p.path)
}
func (p basePath) Rel() string {
if p.rel != "" {
return p.rel
}
return p.path
}
func (p basePath) String() string {
return p.path
}
func (p basePath) withRel(rel string) basePath {
p.path = filepath.Join(p.path, rel)
p.rel = rel
return p
}
// SourcePath is a Path representing a file path rooted from SrcDir
type SourcePath struct {
basePath
}
func (p SourcePath) RelativeToTop() Path {
ensureTestOnly()
return p
}
var _ Path = SourcePath{}
func (p SourcePath) withRel(rel string) SourcePath {
p.basePath = p.basePath.withRel(rel)
return p
}
// safePathForSource is for paths that we expect are safe -- only for use by go
// code that is embedding ninja variables in paths
func safePathForSource(ctx PathContext, pathComponents ...string) (SourcePath, error) {
p, err := validateSafePath(pathComponents...)
ret := SourcePath{basePath{p, ""}}
if err != nil {
return ret, err
}
// absolute path already checked by validateSafePath
// special-case api surface gen files for now
if strings.HasPrefix(ret.String(), ctx.Config().soongOutDir) && !strings.Contains(ret.String(), ctx.Config().soongOutDir+"/.export") {
return ret, fmt.Errorf("source path %q is in output", ret.String())
}
return ret, err
}
// pathForSource creates a SourcePath from pathComponents, but does not check that it exists.
func pathForSource(ctx PathContext, pathComponents ...string) (SourcePath, error) {
p, err := validatePath(pathComponents...)
ret := SourcePath{basePath{p, ""}}
if err != nil {
return ret, err
}
// absolute path already checked by validatePath
// special-case for now
if strings.HasPrefix(ret.String(), ctx.Config().soongOutDir) && !strings.Contains(ret.String(), ctx.Config().soongOutDir+"/.export") {
return ret, fmt.Errorf("source path %q is in output", ret.String())
}
return ret, nil
}
// existsWithDependencies returns true if the path exists, and adds appropriate dependencies to rerun if the
// path does not exist.
func existsWithDependencies(ctx PathGlobContext, path SourcePath) (exists bool, err error) {
var files []string
// Use glob to produce proper dependencies, even though we only want
// a single file.
files, err = ctx.GlobWithDeps(path.String(), nil)
if err != nil {
return false, fmt.Errorf("glob: %s", err.Error())
}
return len(files) > 0, nil
}
// PathForSource joins the provided path components and validates that the result
// neither escapes the source dir nor is in the out dir.
// On error, it will return a usable, but invalid SourcePath, and report a ModuleError.
func PathForSource(ctx PathContext, pathComponents ...string) SourcePath {
path, err := pathForSource(ctx, pathComponents...)
if err != nil {
reportPathError(ctx, err)
}
if pathtools.IsGlob(path.String()) {
ReportPathErrorf(ctx, "path may not contain a glob: %s", path.String())
}
if modCtx, ok := ctx.(ModuleMissingDepsPathContext); ok && ctx.Config().AllowMissingDependencies() {
exists, err := existsWithDependencies(modCtx, path)
if err != nil {
reportPathError(ctx, err)
}
if !exists {
modCtx.AddMissingDependencies([]string{path.String()})
}
} else if exists, _, err := ctx.Config().fs.Exists(path.String()); err != nil {
ReportPathErrorf(ctx, "%s: %s", path, err.Error())
} else if !exists && !ctx.Config().TestAllowNonExistentPaths {
ReportPathErrorf(ctx, "source path %q does not exist", path)
}
return path
}
// MaybeExistentPathForSource joins the provided path components and validates that the result
// neither escapes the source dir nor is in the out dir.
// It does not validate whether the path exists.
func MaybeExistentPathForSource(ctx PathContext, pathComponents ...string) SourcePath {
path, err := pathForSource(ctx, pathComponents...)
if err != nil {
reportPathError(ctx, err)
}
if pathtools.IsGlob(path.String()) {
ReportPathErrorf(ctx, "path may not contain a glob: %s", path.String())
}
return path
}
// ExistentPathForSource returns an OptionalPath with the SourcePath, rooted from SrcDir, *not*
// rooted from the module's local source directory, if the path exists, or an empty OptionalPath if
// it doesn't exist. Dependencies are added so that the ninja file will be regenerated if the state
// of the path changes.
func ExistentPathForSource(ctx PathGlobContext, pathComponents ...string) OptionalPath {
path, err := pathForSource(ctx, pathComponents...)
if err != nil {
reportPathError(ctx, err)
// No need to put the error message into the returned path since it has been reported already.
return OptionalPath{}
}
if pathtools.IsGlob(path.String()) {
ReportPathErrorf(ctx, "path may not contain a glob: %s", path.String())
return OptionalPath{}
}
exists, err := existsWithDependencies(ctx, path)
if err != nil {
reportPathError(ctx, err)
return OptionalPath{}
}
if !exists {
return InvalidOptionalPath(path.String() + " does not exist")
}
return OptionalPathForPath(path)
}
func (p SourcePath) String() string {
if p.path == "" {
return "."
}
return p.path
}
// Join creates a new SourcePath with paths... joined with the current path. The
// provided paths... may not use '..' to escape from the current path.
func (p SourcePath) Join(ctx PathContext, paths ...string) SourcePath {
path, err := validatePath(paths...)
if err != nil {
reportPathError(ctx, err)
}
return p.withRel(path)
}
// join is like Join but does less path validation.
func (p SourcePath) join(ctx PathContext, paths ...string) SourcePath {
path, err := validateSafePath(paths...)
if err != nil {
reportPathError(ctx, err)
}
return p.withRel(path)
}
// OverlayPath returns the overlay for `path' if it exists. This assumes that the
// SourcePath is the path to a resource overlay directory.
func (p SourcePath) OverlayPath(ctx ModuleMissingDepsPathContext, path Path) OptionalPath {
var relDir string
if srcPath, ok := path.(SourcePath); ok {
relDir = srcPath.path
} else {
ReportPathErrorf(ctx, "Cannot find relative path for %s(%s)", reflect.TypeOf(path).Name(), path)
// No need to put the error message into the returned path since it has been reported already.
return OptionalPath{}
}
dir := filepath.Join(p.path, relDir)
// Use Glob so that we are run again if the directory is added.
if pathtools.IsGlob(dir) {
ReportPathErrorf(ctx, "Path may not contain a glob: %s", dir)
}
paths, err := ctx.GlobWithDeps(dir, nil)
if err != nil {
ReportPathErrorf(ctx, "glob: %s", err.Error())
return OptionalPath{}
}
if len(paths) == 0 {
return InvalidOptionalPath(dir + " does not exist")
}
return OptionalPathForPath(PathForSource(ctx, paths[0]))
}
// OutputPath is a Path representing an intermediates file path rooted from the build directory
type OutputPath struct {
basePath
// The soong build directory, i.e. Config.SoongOutDir()
soongOutDir string
fullPath string
}
func (p OutputPath) withRel(rel string) OutputPath {
p.basePath = p.basePath.withRel(rel)
p.fullPath = filepath.Join(p.fullPath, rel)
return p
}
func (p OutputPath) WithoutRel() OutputPath {
p.basePath.rel = filepath.Base(p.basePath.path)
return p
}
func (p OutputPath) getSoongOutDir() string {
return p.soongOutDir
}
func (p OutputPath) RelativeToTop() Path {
return p.outputPathRelativeToTop()
}
func (p OutputPath) outputPathRelativeToTop() OutputPath {
p.fullPath = StringPathRelativeToTop(p.soongOutDir, p.fullPath)
p.soongOutDir = OutSoongDir
return p
}
func (p OutputPath) objPathWithExt(ctx ModuleOutPathContext, subdir, ext string) ModuleObjPath {
return PathForModuleObj(ctx, subdir, pathtools.ReplaceExtension(p.path, ext))
}
var _ Path = OutputPath{}
var _ WritablePath = OutputPath{}
var _ objPathProvider = OutputPath{}
// toolDepPath is a Path representing a dependency of the build tool.
type toolDepPath struct {
basePath
}
func (t toolDepPath) RelativeToTop() Path {
ensureTestOnly()
return t
}
var _ Path = toolDepPath{}
// pathForBuildToolDep returns a toolDepPath representing the given path string.
// There is no validation for the path, as it is "trusted": It may fail
// normal validation checks. For example, it may be an absolute path.
// Only use this function to construct paths for dependencies of the build
// tool invocation.
func pathForBuildToolDep(ctx PathContext, path string) toolDepPath {
return toolDepPath{basePath{path, ""}}
}
// PathForOutput joins the provided paths and returns an OutputPath that is
// validated to not escape the build dir.
// On error, it will return a usable, but invalid OutputPath, and report a ModuleError.
func PathForOutput(ctx PathContext, pathComponents ...string) OutputPath {
path, err := validatePath(pathComponents...)
if err != nil {
reportPathError(ctx, err)
}
fullPath := filepath.Join(ctx.Config().soongOutDir, path)
path = fullPath[len(fullPath)-len(path):]
return OutputPath{basePath{path, ""}, ctx.Config().soongOutDir, fullPath}
}
// PathsForOutput returns Paths rooted from soongOutDir
func PathsForOutput(ctx PathContext, paths []string) WritablePaths {
ret := make(WritablePaths, len(paths))
for i, path := range paths {
ret[i] = PathForOutput(ctx, path)
}
return ret
}
func (p OutputPath) writablePath() {}
func (p OutputPath) String() string {
return p.fullPath
}
// Join creates a new OutputPath with paths... joined with the current path. The
// provided paths... may not use '..' to escape from the current path.
func (p OutputPath) Join(ctx PathContext, paths ...string) OutputPath {
path, err := validatePath(paths...)
if err != nil {
reportPathError(ctx, err)
}
return p.withRel(path)
}
// ReplaceExtension creates a new OutputPath with the extension replaced with ext.
func (p OutputPath) ReplaceExtension(ctx PathContext, ext string) OutputPath {
if strings.Contains(ext, "/") {
ReportPathErrorf(ctx, "extension %q cannot contain /", ext)
}
ret := PathForOutput(ctx, pathtools.ReplaceExtension(p.path, ext))
ret.rel = pathtools.ReplaceExtension(p.rel, ext)
return ret
}
// InSameDir creates a new OutputPath from the directory of the current OutputPath joined with the elements in paths.
func (p OutputPath) InSameDir(ctx PathContext, paths ...string) OutputPath {
path, err := validatePath(paths...)
if err != nil {
reportPathError(ctx, err)
}
ret := PathForOutput(ctx, filepath.Dir(p.path), path)
ret.rel = filepath.Join(filepath.Dir(p.rel), path)
return ret
}
// PathForIntermediates returns an OutputPath representing the top-level
// intermediates directory.
func PathForIntermediates(ctx PathContext, paths ...string) OutputPath {
path, err := validatePath(paths...)
if err != nil {
reportPathError(ctx, err)
}
return PathForOutput(ctx, ".intermediates", path)
}
var _ genPathProvider = SourcePath{}
var _ objPathProvider = SourcePath{}
var _ resPathProvider = SourcePath{}
// PathForModuleSrc returns a Path representing the paths... under the
// module's local source directory.
func PathForModuleSrc(ctx ModuleMissingDepsPathContext, pathComponents ...string) Path {
// Just join the components textually just to make sure that it does not corrupt a fully qualified
// module reference, e.g. if the pathComponents is "://other:foo" then using filepath.Join() or
// validatePath() will corrupt it, e.g. replace "//" with "/". If the path is not a module
// reference then it will be validated by expandOneSrcPath anyway when it calls expandOneSrcPath.
p := strings.Join(pathComponents, string(filepath.Separator))
paths, err := expandOneSrcPath(sourcePathInput{context: ctx, path: p, includeDirs: true})
if err != nil {
if depErr, ok := err.(missingDependencyError); ok {
if ctx.Config().AllowMissingDependencies() {
ctx.AddMissingDependencies(depErr.missingDeps)
} else {
ctx.ModuleErrorf(`%s, is the property annotated with android:"path"?`, depErr.Error())
}
} else {
reportPathError(ctx, err)
}
return nil
} else if len(paths) == 0 {
ReportPathErrorf(ctx, "%q produced no files, expected exactly one", p)
return nil
} else if len(paths) > 1 {
ReportPathErrorf(ctx, "%q produced %d files, expected exactly one", p, len(paths))
}
return paths[0]
}
func pathForModuleSrc(ctx EarlyModulePathContext, paths ...string) SourcePath {
p, err := validatePath(paths...)
if err != nil {
reportPathError(ctx, err)
}
path, err := pathForSource(ctx, ctx.ModuleDir(), p)
if err != nil {
reportPathError(ctx, err)
}
path.basePath.rel = p
return path
}
// PathsWithModuleSrcSubDir takes a list of Paths and returns a new list of Paths where Rel() on each path
// will return the path relative to subDir in the module's source directory. If any input paths are not located
// inside subDir then a path error will be reported.
func PathsWithModuleSrcSubDir(ctx EarlyModulePathContext, paths Paths, subDir string) Paths {
paths = append(Paths(nil), paths...)
subDirFullPath := pathForModuleSrc(ctx, subDir)
for i, path := range paths {
rel := Rel(ctx, subDirFullPath.String(), path.String())
paths[i] = subDirFullPath.join(ctx, rel)
}
return paths
}
// PathWithModuleSrcSubDir takes a Path and returns a Path where Rel() will return the path relative to subDir in the
// module's source directory. If the input path is not located inside subDir then a path error will be reported.
func PathWithModuleSrcSubDir(ctx EarlyModulePathContext, path Path, subDir string) Path {
subDirFullPath := pathForModuleSrc(ctx, subDir)
rel := Rel(ctx, subDirFullPath.String(), path.String())
return subDirFullPath.Join(ctx, rel)
}
// OptionalPathForModuleSrc returns an OptionalPath. The OptionalPath contains a
// valid path if p is non-nil.
func OptionalPathForModuleSrc(ctx ModuleMissingDepsPathContext, p *string) OptionalPath {
if p == nil {
return OptionalPath{}
}
return OptionalPathForPath(PathForModuleSrc(ctx, *p))
}
func (p SourcePath) genPathWithExt(ctx ModuleOutPathContext, subdir, ext string) ModuleGenPath {
return PathForModuleGen(ctx, subdir, pathtools.ReplaceExtension(p.path, ext))
}
func (p SourcePath) objPathWithExt(ctx ModuleOutPathContext, subdir, ext string) ModuleObjPath {
return PathForModuleObj(ctx, subdir, pathtools.ReplaceExtension(p.path, ext))
}
func (p SourcePath) resPathWithName(ctx ModuleOutPathContext, name string) ModuleResPath {
// TODO: Use full directory if the new ctx is not the current ctx?
return PathForModuleRes(ctx, p.path, name)
}
// ModuleOutPath is a Path representing a module's output directory.
type ModuleOutPath struct {
OutputPath
}
func (p ModuleOutPath) RelativeToTop() Path {
p.OutputPath = p.outputPathRelativeToTop()
return p
}
var _ Path = ModuleOutPath{}
var _ WritablePath = ModuleOutPath{}
func (p ModuleOutPath) objPathWithExt(ctx ModuleOutPathContext, subdir, ext string) ModuleObjPath {
return PathForModuleObj(ctx, subdir, pathtools.ReplaceExtension(p.path, ext))
}
// ModuleOutPathContext Subset of ModuleContext functions necessary for output path methods.
type ModuleOutPathContext interface {
PathContext
ModuleName() string
ModuleDir() string
ModuleSubDir() string
}
func pathForModuleOut(ctx ModuleOutPathContext) OutputPath {
return PathForOutput(ctx, ".intermediates", ctx.ModuleDir(), ctx.ModuleName(), ctx.ModuleSubDir())
}
// PathForModuleOut returns a Path representing the paths... under the module's
// output directory.
func PathForModuleOut(ctx ModuleOutPathContext, paths ...string) ModuleOutPath {
p, err := validatePath(paths...)
if err != nil {
reportPathError(ctx, err)
}
return ModuleOutPath{
OutputPath: pathForModuleOut(ctx).withRel(p),
}
}
// ModuleGenPath is a Path representing the 'gen' directory in a module's output
// directory. Mainly used for generated sources.
type ModuleGenPath struct {
ModuleOutPath
}
func (p ModuleGenPath) RelativeToTop() Path {
p.OutputPath = p.outputPathRelativeToTop()
return p
}
var _ Path = ModuleGenPath{}
var _ WritablePath = ModuleGenPath{}
var _ genPathProvider = ModuleGenPath{}
var _ objPathProvider = ModuleGenPath{}
// PathForModuleGen returns a Path representing the paths... under the module's
// `gen' directory.
func PathForModuleGen(ctx ModuleOutPathContext, paths ...string) ModuleGenPath {
p, err := validatePath(paths...)
if err != nil {
reportPathError(ctx, err)
}
return ModuleGenPath{
ModuleOutPath: ModuleOutPath{
OutputPath: pathForModuleOut(ctx).withRel("gen").withRel(p),
},
}
}
func (p ModuleGenPath) genPathWithExt(ctx ModuleOutPathContext, subdir, ext string) ModuleGenPath {
// TODO: make a different path for local vs remote generated files?
return PathForModuleGen(ctx, subdir, pathtools.ReplaceExtension(p.path, ext))
}
func (p ModuleGenPath) objPathWithExt(ctx ModuleOutPathContext, subdir, ext string) ModuleObjPath {
return PathForModuleObj(ctx, subdir, pathtools.ReplaceExtension(p.path, ext))
}
// ModuleObjPath is a Path representing the 'obj' directory in a module's output
// directory. Used for compiled objects.
type ModuleObjPath struct {
ModuleOutPath
}
func (p ModuleObjPath) RelativeToTop() Path {
p.OutputPath = p.outputPathRelativeToTop()
return p
}
var _ Path = ModuleObjPath{}
var _ WritablePath = ModuleObjPath{}
// PathForModuleObj returns a Path representing the paths... under the module's
// 'obj' directory.
func PathForModuleObj(ctx ModuleOutPathContext, pathComponents ...string) ModuleObjPath {
p, err := validatePath(pathComponents...)
if err != nil {
reportPathError(ctx, err)
}
return ModuleObjPath{PathForModuleOut(ctx, "obj", p)}
}
// ModuleResPath is a a Path representing the 'res' directory in a module's
// output directory.
type ModuleResPath struct {
ModuleOutPath
}
func (p ModuleResPath) RelativeToTop() Path {
p.OutputPath = p.outputPathRelativeToTop()
return p
}
var _ Path = ModuleResPath{}
var _ WritablePath = ModuleResPath{}
// PathForModuleRes returns a Path representing the paths... under the module's
// 'res' directory.
func PathForModuleRes(ctx ModuleOutPathContext, pathComponents ...string) ModuleResPath {
p, err := validatePath(pathComponents...)
if err != nil {
reportPathError(ctx, err)
}
return ModuleResPath{PathForModuleOut(ctx, "res", p)}
}
// InstallPath is a Path representing a installed file path rooted from the build directory
type InstallPath struct {
basePath
// The soong build directory, i.e. Config.SoongOutDir()
soongOutDir string
// partitionDir is the part of the InstallPath that is automatically determined according to the context.
// For example, it is host/<os>-<arch> for host modules, and target/product/<device>/<partition> for device modules.
partitionDir string
partition string
// makePath indicates whether this path is for Soong (false) or Make (true).
makePath bool
}
// Will panic if called from outside a test environment.
func ensureTestOnly() {
if PrefixInList(os.Args, "-test.") {
return
}
panic(fmt.Errorf("Not in test. Command line:\n %s", strings.Join(os.Args, "\n ")))
}
func (p InstallPath) RelativeToTop() Path {
ensureTestOnly()
p.soongOutDir = OutSoongDir
return p
}
func (p InstallPath) getSoongOutDir() string {
return p.soongOutDir
}
func (p InstallPath) ReplaceExtension(ctx PathContext, ext string) OutputPath {
panic("Not implemented")
}
var _ Path = InstallPath{}
var _ WritablePath = InstallPath{}
func (p InstallPath) writablePath() {}
func (p InstallPath) String() string {
if p.makePath {
// Make path starts with out/ instead of out/soong.
return filepath.Join(p.soongOutDir, "../", p.path)
} else {
return filepath.Join(p.soongOutDir, p.path)
}
}
// PartitionDir returns the path to the partition where the install path is rooted at. It is
// out/soong/target/product/<device>/<partition> for device modules, and out/soong/host/<os>-<arch> for host modules.
// The ./soong is dropped if the install path is for Make.
func (p InstallPath) PartitionDir() string {
if p.makePath {
return filepath.Join(p.soongOutDir, "../", p.partitionDir)
} else {
return filepath.Join(p.soongOutDir, p.partitionDir)
}
}
func (p InstallPath) Partition() string {
return p.partition
}
// Join creates a new InstallPath with paths... joined with the current path. The
// provided paths... may not use '..' to escape from the current path.
func (p InstallPath) Join(ctx PathContext, paths ...string) InstallPath {
path, err := validatePath(paths...)
if err != nil {
reportPathError(ctx, err)
}
return p.withRel(path)
}
func (p InstallPath) withRel(rel string) InstallPath {
p.basePath = p.basePath.withRel(rel)
return p
}
// Deprecated: ToMakePath is a noop, PathForModuleInstall always returns Make paths when building
// embedded in Make.
func (p InstallPath) ToMakePath() InstallPath {
p.makePath = true
return p
}
// PathForModuleInstall returns a Path representing the install path for the
// module appended with paths...
func PathForModuleInstall(ctx ModuleInstallPathContext, pathComponents ...string) InstallPath {
os, arch := osAndArch(ctx)
partition := modulePartition(ctx, os)
return makePathForInstall(ctx, os, arch, partition, ctx.Debug(), pathComponents...)
}
// PathForHostDexInstall returns an InstallPath representing the install path for the
// module appended with paths...
func PathForHostDexInstall(ctx ModuleInstallPathContext, pathComponents ...string) InstallPath {
return makePathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "", ctx.Debug(), pathComponents...)
}
// PathForModuleInPartitionInstall is similar to PathForModuleInstall but partition is provided by the caller
func PathForModuleInPartitionInstall(ctx ModuleInstallPathContext, partition string, pathComponents ...string) InstallPath {
os, arch := osAndArch(ctx)
return makePathForInstall(ctx, os, arch, partition, ctx.Debug(), pathComponents...)
}
func osAndArch(ctx ModuleInstallPathContext) (OsType, ArchType) {
os := ctx.Os()
arch := ctx.Arch().ArchType
forceOS, forceArch := ctx.InstallForceOS()
if forceOS != nil {
os = *forceOS
}
if forceArch != nil {
arch = *forceArch
}
return os, arch
}
func makePathForInstall(ctx ModuleInstallPathContext, os OsType, arch ArchType, partition string, debug bool, pathComponents ...string) InstallPath {
ret := pathForInstall(ctx, os, arch, partition, debug, pathComponents...)
return ret
}
func pathForInstall(ctx PathContext, os OsType, arch ArchType, partition string, debug bool,
pathComponents ...string) InstallPath {
var partitionPaths []string
if os.Class == Device {
partitionPaths = []string{"target", "product", ctx.Config().DeviceName(), partition}
} else {
osName := os.String()
if os == Linux {
// instead of linux_glibc
osName = "linux"
}
if os == LinuxMusl && ctx.Config().UseHostMusl() {
// When using musl instead of glibc, use "linux" instead of "linux_musl". When cross
// compiling we will still use "linux_musl".
osName = "linux"
}
// SOONG_HOST_OUT is set to out/host/$(HOST_OS)-$(HOST_PREBUILT_ARCH)
// and HOST_PREBUILT_ARCH is forcibly set to x86 even on x86_64 hosts. We don't seem
// to have a plan to fix it (see the comment in build/make/core/envsetup.mk).
// Let's keep using x86 for the existing cases until we have a need to support
// other architectures.
archName := arch.String()
if os.Class == Host && (arch == X86_64 || arch == Common) {
archName = "x86"
}
partitionPaths = []string{"host", osName + "-" + archName, partition}
}
if debug {
partitionPaths = append([]string{"debug"}, partitionPaths...)
}
partitionPath, err := validatePath(partitionPaths...)
if err != nil {
reportPathError(ctx, err)
}
base := InstallPath{
basePath: basePath{partitionPath, ""},
soongOutDir: ctx.Config().soongOutDir,
partitionDir: partitionPath,
partition: partition,
}
if ctx.Config().KatiEnabled() {
base.makePath = true
}
return base.Join(ctx, pathComponents...)
}
func pathForNdkOrSdkInstall(ctx PathContext, prefix string, paths []string) InstallPath {
base := InstallPath{
basePath: basePath{prefix, ""},
soongOutDir: ctx.Config().soongOutDir,
partitionDir: prefix,
makePath: false,
}
return base.Join(ctx, paths...)
}
func PathForNdkInstall(ctx PathContext, paths ...string) InstallPath {
return pathForNdkOrSdkInstall(ctx, "ndk", paths)
}
func PathForMainlineSdksInstall(ctx PathContext, paths ...string) InstallPath {
return pathForNdkOrSdkInstall(ctx, "mainline-sdks", paths)
}
func InstallPathToOnDevicePath(ctx PathContext, path InstallPath) string {
rel := Rel(ctx, strings.TrimSuffix(path.PartitionDir(), path.partition), path.String())
return "/" + rel
}
func modulePartition(ctx ModuleInstallPathContext, os OsType) string {
var partition string
if ctx.InstallInTestcases() {
// "testcases" install directory can be used for host or device modules.
partition = "testcases"
} else if os.Class == Device {
if ctx.InstallInData() {
partition = "data"
} else if ctx.InstallInRamdisk() {
if ctx.DeviceConfig().BoardUsesRecoveryAsBoot() {
partition = "recovery/root/first_stage_ramdisk"
} else {
partition = "ramdisk"
}
if !ctx.InstallInRoot() {
partition += "/system"
}
} else if ctx.InstallInVendorRamdisk() {
// The module is only available after switching root into
// /first_stage_ramdisk. To expose the module before switching root
// on a device without a dedicated recovery partition, install the
// recovery variant.
if ctx.DeviceConfig().BoardMoveRecoveryResourcesToVendorBoot() {
partition = "vendor_ramdisk/first_stage_ramdisk"
} else {
partition = "vendor_ramdisk"
}
if !ctx.InstallInRoot() {
partition += "/system"
}
} else if ctx.InstallInDebugRamdisk() {
partition = "debug_ramdisk"
} else if ctx.InstallInRecovery() {
if ctx.InstallInRoot() {
partition = "recovery/root"
} else {
// the layout of recovery partion is the same as that of system partition
partition = "recovery/root/system"
}
} else if ctx.SocSpecific() {
partition = ctx.DeviceConfig().VendorPath()
} else if ctx.DeviceSpecific() {
partition = ctx.DeviceConfig().OdmPath()
} else if ctx.ProductSpecific() {
partition = ctx.DeviceConfig().ProductPath()
} else if ctx.SystemExtSpecific() {
partition = ctx.DeviceConfig().SystemExtPath()
} else if ctx.InstallInRoot() {
partition = "root"
} else {
partition = "system"
}
if ctx.InstallInSanitizerDir() {
partition = "data/asan/" + partition
}
}
return partition
}
type InstallPaths []InstallPath
// Paths returns the InstallPaths as a Paths
func (p InstallPaths) Paths() Paths {
if p == nil {
return nil
}
ret := make(Paths, len(p))
for i, path := range p {
ret[i] = path
}
return ret
}
// Strings returns the string forms of the install paths.
func (p InstallPaths) Strings() []string {
if p == nil {
return nil
}
ret := make([]string, len(p))
for i, path := range p {
ret[i] = path.String()
}
return ret
}
// validatePathInternal ensures that a path does not leave its component, and
// optionally doesn't contain Ninja variables.
func validatePathInternal(allowNinjaVariables bool, pathComponents ...string) (string, error) {
for _, path := range pathComponents {
if !allowNinjaVariables && strings.Contains(path, "$") {
return "", fmt.Errorf("Path contains invalid character($): %s", path)
}
path := filepath.Clean(path)
if path == ".." || strings.HasPrefix(path, "../") || strings.HasPrefix(path, "/") {
return "", fmt.Errorf("Path is outside directory: %s", path)
}
}
// TODO: filepath.Join isn't necessarily correct with embedded ninja
// variables. '..' may remove the entire ninja variable, even if it
// will be expanded to multiple nested directories.
return filepath.Join(pathComponents...), nil
}
// validateSafePath validates a path that we trust (may contain ninja
// variables). Ensures that each path component does not attempt to leave its
// component. Returns a joined version of each path component.
func validateSafePath(pathComponents ...string) (string, error) {
return validatePathInternal(true, pathComponents...)
}
// validatePath validates that a path does not include ninja variables, and that
// each path component does not attempt to leave its component. Returns a joined
// version of each path component.
func validatePath(pathComponents ...string) (string, error) {
return validatePathInternal(false, pathComponents...)
}
func PathForPhony(ctx PathContext, phony string) WritablePath {
if strings.ContainsAny(phony, "$/") {
ReportPathErrorf(ctx, "Phony target contains invalid character ($ or /): %s", phony)
}
return PhonyPath{basePath{phony, ""}}
}
type PhonyPath struct {
basePath
}
func (p PhonyPath) writablePath() {}
func (p PhonyPath) getSoongOutDir() string {
// A phone path cannot contain any / so cannot be relative to the build directory.
return ""
}
func (p PhonyPath) RelativeToTop() Path {
ensureTestOnly()
// A phony path cannot contain any / so does not have a build directory so switching to a new
// build directory has no effect so just return this path.
return p
}
func (p PhonyPath) ReplaceExtension(ctx PathContext, ext string) OutputPath {
panic("Not implemented")
}
var _ Path = PhonyPath{}
var _ WritablePath = PhonyPath{}
type testPath struct {
basePath
}
func (p testPath) RelativeToTop() Path {
ensureTestOnly()
return p
}
func (p testPath) String() string {
return p.path
}
var _ Path = testPath{}
// PathForTesting returns a Path constructed from joining the elements of paths with '/'. It should only be used from
// within tests.
func PathForTesting(paths ...string) Path {
p, err := validateSafePath(paths...)
if err != nil {
panic(err)
}
return testPath{basePath{path: p, rel: p}}
}
func PathForTestingWithRel(path, rel string) Path {
p, err := validateSafePath(path, rel)
if err != nil {
panic(err)
}
r, err := validatePath(rel)
if err != nil {
panic(err)
}
return testPath{basePath{path: p, rel: r}}
}
// PathsForTesting returns a Path constructed from each element in strs. It should only be used from within tests.
func PathsForTesting(strs ...string) Paths {
p := make(Paths, len(strs))
for i, s := range strs {
p[i] = PathForTesting(s)
}
return p
}
type testPathContext struct {
config Config
}
func (x *testPathContext) Config() Config { return x.config }
func (x *testPathContext) AddNinjaFileDeps(...string) {}
// PathContextForTesting returns a PathContext that can be used in tests, for example to create an OutputPath with
// PathForOutput.
func PathContextForTesting(config Config) PathContext {
return &testPathContext{
config: config,
}
}
type testModuleInstallPathContext struct {
baseModuleContext
inData bool
inTestcases bool
inSanitizerDir bool
inRamdisk bool
inVendorRamdisk bool
inDebugRamdisk bool
inRecovery bool
inRoot bool
forceOS *OsType
forceArch *ArchType
}
func (m testModuleInstallPathContext) Config() Config {
return m.baseModuleContext.config
}
func (testModuleInstallPathContext) AddNinjaFileDeps(deps ...string) {}
func (m testModuleInstallPathContext) InstallInData() bool {
return m.inData
}
func (m testModuleInstallPathContext) InstallInTestcases() bool {
return m.inTestcases
}
func (m testModuleInstallPathContext) InstallInSanitizerDir() bool {
return m.inSanitizerDir
}
func (m testModuleInstallPathContext) InstallInRamdisk() bool {
return m.inRamdisk
}
func (m testModuleInstallPathContext) InstallInVendorRamdisk() bool {
return m.inVendorRamdisk
}
func (m testModuleInstallPathContext) InstallInDebugRamdisk() bool {
return m.inDebugRamdisk
}
func (m testModuleInstallPathContext) InstallInRecovery() bool {
return m.inRecovery
}
func (m testModuleInstallPathContext) InstallInRoot() bool {
return m.inRoot
}
func (m testModuleInstallPathContext) InstallForceOS() (*OsType, *ArchType) {
return m.forceOS, m.forceArch
}
// Construct a minimal ModuleInstallPathContext for testing. Note that baseModuleContext is
// default-initialized, which leaves blueprint.baseModuleContext set to nil, so methods that are
// delegated to it will panic.
func ModuleInstallPathContextForTesting(config Config) ModuleInstallPathContext {
ctx := &testModuleInstallPathContext{}
ctx.config = config
ctx.os = Android
return ctx
}
// Rel performs the same function as filepath.Rel, but reports errors to a PathContext, and reports an error if
// targetPath is not inside basePath.
func Rel(ctx PathContext, basePath string, targetPath string) string {
rel, isRel := MaybeRel(ctx, basePath, targetPath)
if !isRel {
ReportPathErrorf(ctx, "path %q is not under path %q", targetPath, basePath)
return ""
}
return rel
}
// MaybeRel performs the same function as filepath.Rel, but reports errors to a PathContext, and returns false if
// targetPath is not inside basePath.
func MaybeRel(ctx PathContext, basePath string, targetPath string) (string, bool) {
rel, isRel, err := maybeRelErr(basePath, targetPath)
if err != nil {
reportPathError(ctx, err)
}
return rel, isRel
}
func maybeRelErr(basePath string, targetPath string) (string, bool, error) {
// filepath.Rel returns an error if one path is absolute and the other is not, handle that case first.
if filepath.IsAbs(basePath) != filepath.IsAbs(targetPath) {
return "", false, nil
}
rel, err := filepath.Rel(basePath, targetPath)
if err != nil {
return "", false, err
} else if rel == ".." || strings.HasPrefix(rel, "../") || strings.HasPrefix(rel, "/") {
return "", false, nil
}
return rel, true, nil
}
// Writes a file to the output directory. Attempting to write directly to the output directory
// will fail due to the sandbox of the soong_build process.
// Only writes the file if the file doesn't exist or if it has different contents, to prevent
// updating the timestamp if no changes would be made. (This is better for incremental
// performance.)
func WriteFileToOutputDir(path WritablePath, data []byte, perm os.FileMode) error {
absPath := absolutePath(path.String())
err := os.MkdirAll(filepath.Dir(absPath), 0777)
if err != nil {
return err
}
return pathtools.WriteFileIfChanged(absPath, data, perm)
}
func RemoveAllOutputDir(path WritablePath) error {
return os.RemoveAll(absolutePath(path.String()))
}
func CreateOutputDirIfNonexistent(path WritablePath, perm os.FileMode) error {
dir := absolutePath(path.String())
return createDirIfNonexistent(dir, perm)
}
func createDirIfNonexistent(dir string, perm os.FileMode) error {
if _, err := os.Stat(dir); os.IsNotExist(err) {
return os.MkdirAll(dir, os.ModePerm)
} else {
return err
}
}
// absolutePath is deliberately private so that Soong's Go plugins can't use it to find and
// read arbitrary files without going through the methods in the current package that track
// dependencies.
func absolutePath(path string) string {
if filepath.IsAbs(path) {
return path
}
return filepath.Join(absSrcDir, path)
}
// A DataPath represents the path of a file to be used as data, for example
// a test library to be installed alongside a test.
// The data file should be installed (copied from `<SrcPath>`) to
// `<install_root>/<RelativeInstallPath>/<filename>`, or
// `<install_root>/<filename>` if RelativeInstallPath is empty.
type DataPath struct {
// The path of the data file that should be copied into the data directory
SrcPath Path
// The install path of the data file, relative to the install root.
RelativeInstallPath string
}
// PathsIfNonNil returns a Paths containing only the non-nil input arguments.
func PathsIfNonNil(paths ...Path) Paths {
if len(paths) == 0 {
// Fast path for empty argument list
return nil
} else if len(paths) == 1 {
// Fast path for a single argument
if paths[0] != nil {
return paths
} else {
return nil
}
}
ret := make(Paths, 0, len(paths))
for _, path := range paths {
if path != nil {
ret = append(ret, path)
}
}
if len(ret) == 0 {
return nil
}
return ret
}
var thirdPartyDirPrefixExceptions = []*regexp.Regexp{
regexp.MustCompile("^vendor/[^/]*google[^/]*/"),
regexp.MustCompile("^hardware/google/"),
regexp.MustCompile("^hardware/interfaces/"),
regexp.MustCompile("^hardware/libhardware[^/]*/"),
regexp.MustCompile("^hardware/ril/"),
}
func IsThirdPartyPath(path string) bool {
thirdPartyDirPrefixes := []string{"external/", "vendor/", "hardware/"}
if HasAnyPrefix(path, thirdPartyDirPrefixes) {
for _, prefix := range thirdPartyDirPrefixExceptions {
if prefix.MatchString(path) {
return false
}
}
return true
}
return false
}
// PathsDepSet is a thin type-safe wrapper around the generic depSet. It always uses
// topological order.
type PathsDepSet struct {
depSet
}
// newPathsDepSet returns an immutable PathsDepSet with the given direct and
// transitive contents.
func newPathsDepSet(direct Paths, transitive []*PathsDepSet) *PathsDepSet {
return &PathsDepSet{*newDepSet(TOPOLOGICAL, direct, transitive)}
}
// ToList returns the PathsDepSet flattened to a list in topological order.
func (d *PathsDepSet) ToList() Paths {
if d == nil {
return nil
}
return d.depSet.ToList().(Paths)
}