diff options
-rw-r--r-- | android/paths.go | 136 |
1 files changed, 61 insertions, 75 deletions
diff --git a/android/paths.go b/android/paths.go index 3d4d3f30..3bb5d1b7 100644 --- a/android/paths.go +++ b/android/paths.go @@ -195,20 +195,6 @@ type Paths []Path // PathsForSource returns Paths rooted from SrcDir func PathsForSource(ctx PathContext, paths []string) Paths { - if ctx.Config().AllowMissingDependencies() { - if modCtx, ok := ctx.(ModuleContext); ok { - ret := make(Paths, 0, len(paths)) - for _, path := range paths { - p := ExistentPathForSource(ctx, path) - if p.Valid() { - ret = append(ret, p.Path()) - } else { - modCtx.AddMissingDependencies([]string{path}) - } - } - return ret - } - } ret := make(Paths, len(paths)) for i, path := range paths { ret[i] = PathForSource(ctx, path) @@ -507,100 +493,100 @@ func safePathForSource(ctx PathContext, path string) SourcePath { return ret } -// 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 { +// 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, ctx.Config(), ""}} if err != nil { - reportPathError(ctx, err) - return ret + return ret, err } abs, err := filepath.Abs(ret.String()) if err != nil { - reportPathError(ctx, err) - return ret + return ret, err } buildroot, err := filepath.Abs(ctx.Config().buildDir) if err != nil { - reportPathError(ctx, err) - return ret + return ret, err } if strings.HasPrefix(abs, buildroot) { - reportPathErrorf(ctx, "source path %s is in output", abs) - return ret + return ret, fmt.Errorf("source path %s is in output", abs) + } + + if pathtools.IsGlob(ret.String()) { + return ret, fmt.Errorf("path may not contain a glob: %s", 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 PathContext, path SourcePath) (exists bool, err error) { + var files []string + + if gctx, ok := ctx.(PathGlobContext); ok { + // Use glob to produce proper dependencies, even though we only want + // a single file. + files, err = gctx.GlobWithDeps(path.String(), nil) + } else { + var deps []string + // We cannot add build statements in this context, so we fall back to + // AddNinjaFileDeps + files, deps, err = pathtools.Glob(path.String(), nil) + ctx.AddNinjaFileDeps(deps...) } - if exists, _, err := ctx.Fs().Exists(ret.String()); err != nil { - reportPathErrorf(ctx, "%s: %s", ret, err.Error()) + 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 modCtx, ok := ctx.(ModuleContext); ok && ctx.Config().AllowMissingDependencies() { + exists, err := existsWithDependencies(ctx, path) + if err != nil { + reportPathError(ctx, err) + } + if !exists { + modCtx.AddMissingDependencies([]string{path.String()}) + } + } else if exists, _, err := ctx.Fs().Exists(path.String()); err != nil { + reportPathErrorf(ctx, "%s: %s", path, err.Error()) } else if !exists { - reportPathErrorf(ctx, "source path %s does not exist", ret) + reportPathErrorf(ctx, "source path %s does not exist", path) } - return ret + return path } // ExistentPathForSource returns an OptionalPath with the SourcePath 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 PathContext, pathComponents ...string) OptionalPath { - p, err := validatePath(pathComponents...) + path, err := pathForSource(ctx, pathComponents...) if err != nil { reportPathError(ctx, err) return OptionalPath{} } - path := SourcePath{basePath{p, ctx.Config(), ""}} - abs, err := filepath.Abs(path.String()) + exists, err := existsWithDependencies(ctx, path) if err != nil { reportPathError(ctx, err) return OptionalPath{} } - buildroot, err := filepath.Abs(ctx.Config().buildDir) - if err != nil { - reportPathError(ctx, err) - return OptionalPath{} - } - if strings.HasPrefix(abs, buildroot) { - reportPathErrorf(ctx, "source path %s is in output", abs) - return OptionalPath{} - } - - if pathtools.IsGlob(path.String()) { - reportPathErrorf(ctx, "path may not contain a glob: %s", path.String()) + if !exists { return OptionalPath{} } - - if gctx, ok := ctx.(PathGlobContext); ok { - // Use glob to produce proper dependencies, even though we only want - // a single file. - files, err := gctx.GlobWithDeps(path.String(), nil) - if err != nil { - reportPathErrorf(ctx, "glob: %s", err.Error()) - return OptionalPath{} - } - - if len(files) == 0 { - return OptionalPath{} - } - } else { - // We cannot add build statements in this context, so we fall back to - // AddNinjaFileDeps - files, dirs, err := pathtools.Glob(path.String(), nil) - if err != nil { - reportPathErrorf(ctx, "glob: %s", err.Error()) - return OptionalPath{} - } - - ctx.AddNinjaFileDeps(dirs...) - - if len(files) == 0 { - return OptionalPath{} - } - - ctx.AddNinjaFileDeps(path.String()) - } return OptionalPathForPath(path) } |