// Copyright 2018 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" "sort" "strings" "github.com/google/blueprint" "github.com/google/blueprint/proptools" ) // RuleBuilder provides an alternative to ModuleContext.Rule and ModuleContext.Build to add a command line to the build // graph. type RuleBuilder struct { commands []*RuleBuilderCommand installs RuleBuilderInstalls temporariesSet map[WritablePath]bool restat bool missingDeps []string } // NewRuleBuilder returns a newly created RuleBuilder. func NewRuleBuilder() *RuleBuilder { return &RuleBuilder{ temporariesSet: make(map[WritablePath]bool), } } // RuleBuilderInstall is a tuple of install from and to locations. type RuleBuilderInstall struct { From Path To string } type RuleBuilderInstalls []RuleBuilderInstall // String returns the RuleBuilderInstalls in the form used by $(call copy-many-files) in Make, a space separated // list of from:to tuples. func (installs RuleBuilderInstalls) String() string { sb := strings.Builder{} for i, install := range installs { if i != 0 { sb.WriteRune(' ') } sb.WriteString(install.From.String()) sb.WriteRune(':') sb.WriteString(install.To) } return sb.String() } // MissingDeps adds modules to the list of missing dependencies. If MissingDeps // is called with a non-empty input, any call to Build will result in a rule // that will print an error listing the missing dependencies and fail. // MissingDeps should only be called if Config.AllowMissingDependencies() is // true. func (r *RuleBuilder) MissingDeps(missingDeps []string) { r.missingDeps = append(r.missingDeps, missingDeps...) } // Restat marks the rule as a restat rule, which will be passed to ModuleContext.Rule in BuildParams.Restat. func (r *RuleBuilder) Restat() *RuleBuilder { r.restat = true return r } // Install associates an output of the rule with an install location, which can be retrieved later using // RuleBuilder.Installs. func (r *RuleBuilder) Install(from Path, to string) { r.installs = append(r.installs, RuleBuilderInstall{from, to}) } // Command returns a new RuleBuilderCommand for the rule. The commands will be ordered in the rule by when they were // created by this method. That can be mutated through their methods in any order, as long as the mutations do not // race with any call to Build. func (r *RuleBuilder) Command() *RuleBuilderCommand { command := &RuleBuilderCommand{} r.commands = append(r.commands, command) return command } // Temporary marks an output of a command as an intermediate file that will be used as an input to another command // in the same rule, and should not be listed in Outputs. func (r *RuleBuilder) Temporary(path WritablePath) { r.temporariesSet[path] = true } // DeleteTemporaryFiles adds a command to the rule that deletes any outputs that have been marked using Temporary // when the rule runs. DeleteTemporaryFiles should be called after all calls to Temporary. func (r *RuleBuilder) DeleteTemporaryFiles() { var temporariesList WritablePaths for intermediate := range r.temporariesSet { temporariesList = append(temporariesList, intermediate) } sort.Slice(temporariesList, func(i, j int) bool { return temporariesList[i].String() < temporariesList[j].String() }) r.Command().Text("rm").Flag("-f").Outputs(temporariesList) } // Inputs returns the list of paths that were passed to the RuleBuilderCommand methods that take input paths, such // as RuleBuilderCommand.Input, RuleBuilderComand.Implicit, or RuleBuilderCommand.FlagWithInput. Inputs to a command // that are also outputs of another command in the same RuleBuilder are filtered out. func (r *RuleBuilder) Inputs() Paths { outputs := r.outputSet() inputs := make(map[string]Path) for _, c := range r.commands { for _, input := range c.inputs { if _, isOutput := outputs[input.String()]; !isOutput { inputs[input.String()] = input } } } var inputList Paths for _, input := range inputs { inputList = append(inputList, input) } sort.Slice(inputList, func(i, j int) bool { return inputList[i].String() < inputList[j].String() }) return inputList } func (r *RuleBuilder) outputSet() map[string]WritablePath { outputs := make(map[string]WritablePath) for _, c := range r.commands { for _, output := range c.outputs { outputs[output.String()] = output } } return outputs } // Outputs returns the list of paths that were passed to the RuleBuilderCommand methods that take output paths, such // as RuleBuilderCommand.Output, RuleBuilderCommand.ImplicitOutput, or RuleBuilderCommand.FlagWithInput. func (r *RuleBuilder) Outputs() WritablePaths { outputs := r.outputSet() var outputList WritablePaths for _, output := range outputs { if !r.temporariesSet[output] { outputList = append(outputList, output) } } sort.Slice(outputList, func(i, j int) bool { return outputList[i].String() < outputList[j].String() }) return outputList } // DepFiles returns the list of paths that were passed to the RuleBuilderCommand methods that take depfile paths, such // as RuleBuilderCommand.DepFile or RuleBuilderCommand.FlagWithDepFile. func (r *RuleBuilder) DepFiles() WritablePaths { var depFiles WritablePaths for _, c := range r.commands { for _, depFile := range c.depFiles { depFiles = append(depFiles, depFile) } } return depFiles } // Installs returns the list of tuples passed to Install. func (r *RuleBuilder) Installs() RuleBuilderInstalls { return append(RuleBuilderInstalls(nil), r.installs...) } func (r *RuleBuilder) toolsSet() map[string]Path { tools := make(map[string]Path) for _, c := range r.commands { for _, tool := range c.tools { tools[tool.String()] = tool } } return tools } // Tools returns the list of paths that were passed to the RuleBuilderCommand.Tool method. func (r *RuleBuilder) Tools() Paths { toolsSet := r.toolsSet() var toolsList Paths for _, tool := range toolsSet { toolsList = append(toolsList, tool) } sort.Slice(toolsList, func(i, j int) bool { return toolsList[i].String() < toolsList[j].String() }) return toolsList } // Commands returns a slice containing a the built command line for each call to RuleBuilder.Command. func (r *RuleBuilder) Commands() []string { var commands []string for _, c := range r.commands { commands = append(commands, string(c.buf)) } return commands } // BuilderContext is a subset of ModuleContext and SingletonContext. type BuilderContext interface { PathContext Rule(PackageContext, string, blueprint.RuleParams, ...string) blueprint.Rule Build(PackageContext, BuildParams) } var _ BuilderContext = ModuleContext(nil) var _ BuilderContext = SingletonContext(nil) func (r *RuleBuilder) depFileMergerCmd(ctx PathContext, depFiles WritablePaths) *RuleBuilderCommand { return (&RuleBuilderCommand{}). Tool(ctx.Config().HostToolPath(ctx, "dep_fixer")). Flags(depFiles.Strings()) } // Build adds the built command line to the build graph, with dependencies on Inputs and Tools, and output files for // Outputs. func (r *RuleBuilder) Build(pctx PackageContext, ctx BuilderContext, name string, desc string) { name = ninjaNameEscape(name) if len(r.missingDeps) > 0 { ctx.Build(pctx, BuildParams{ Rule: ErrorRule, Outputs: r.Outputs(), Description: desc, Args: map[string]string{ "error": "missing dependencies: " + strings.Join(r.missingDeps, ", "), }, }) return } tools := r.Tools() commands := r.Commands() var depFile WritablePath var depFormat blueprint.Deps if depFiles := r.DepFiles(); len(depFiles) > 0 { depFile = depFiles[0] depFormat = blueprint.DepsGCC if len(depFiles) > 1 { // Add a command locally that merges all depfiles together into the first depfile. cmd := r.depFileMergerCmd(ctx, depFiles) commands = append(commands, string(cmd.buf)) tools = append(tools, cmd.tools...) } } // Ninja doesn't like multiple outputs when depfiles are enabled, move all but the first output to // ImplicitOutputs. RuleBuilder never uses "$out", so the distinction between Outputs and ImplicitOutputs // doesn't matter. var output WritablePath var implicitOutputs WritablePaths if outputs := r.Outputs(); len(outputs) > 0 { output = outputs[0] implicitOutputs = outputs[1:] } if len(commands) > 0 { ctx.Build(pctx, BuildParams{ Rule: ctx.Rule(pctx, name, blueprint.RuleParams{ Command: strings.Join(proptools.NinjaEscapeList(commands), " && "), CommandDeps: tools.Strings(), Restat: r.restat, }), Implicits: r.Inputs(), Output: output, ImplicitOutputs: implicitOutputs, Depfile: depFile, Deps: depFormat, Description: desc, }) } } // RuleBuilderCommand is a builder for a command in a command line. It can be mutated by its methods to add to the // command and track dependencies. The methods mutate the RuleBuilderCommand in place, as well as return the // RuleBuilderCommand, so they can be used chained or unchained. All methods that add text implicitly add a single // space as a separator from the previous method. type RuleBuilderCommand struct { buf []byte inputs Paths outputs WritablePaths depFiles WritablePaths tools Paths } // Text adds the specified raw text to the command line. The text should not contain input or output paths or the // rule will not have them listed in its dependencies or outputs. func (c *RuleBuilderCommand) Text(text string) *RuleBuilderCommand { if len(c.buf) > 0 { c.buf = append(c.buf, ' ') } c.buf = append(c.buf, text...) return c } // Textf adds the specified formatted text to the command line. The text should not contain input or output paths or // the rule will not have them listed in its dependencies or outputs. func (c *RuleBuilderCommand) Textf(format string, a ...interface{}) *RuleBuilderCommand { return c.Text(fmt.Sprintf(format, a...)) } // Flag adds the specified raw text to the command line. The text should not contain input or output paths or the // rule will not have them listed in its dependencies or outputs. func (c *RuleBuilderCommand) Flag(flag string) *RuleBuilderCommand { return c.Text(flag) } // Flags adds the specified raw text to the command line. The text should not contain input or output paths or the // rule will not have them listed in its dependencies or outputs. func (c *RuleBuilderCommand) Flags(flags []string) *RuleBuilderCommand { for _, flag := range flags { c.Text(flag) } return c } // FlagWithArg adds the specified flag and argument text to the command line, with no separator between them. The flag // and argument should not contain input or output paths or the rule will not have them listed in its dependencies or // outputs. func (c *RuleBuilderCommand) FlagWithArg(flag, arg string) *RuleBuilderCommand { return c.Text(flag + arg) } // FlagForEachArg adds the specified flag joined with each argument to the command line. The result is identical to // calling FlagWithArg for argument. func (c *RuleBuilderCommand) FlagForEachArg(flag string, args []string) *RuleBuilderCommand { for _, arg := range args { c.FlagWithArg(flag, arg) } return c } // FlagWithList adds the specified flag and list of arguments to the command line, with the arguments joined by sep // and no separator between the flag and arguments. The flag and arguments should not contain input or output paths or // the rule will not have them listed in its dependencies or outputs. func (c *RuleBuilderCommand) FlagWithList(flag string, list []string, sep string) *RuleBuilderCommand { return c.Text(flag + strings.Join(list, sep)) } // Tool adds the specified tool path to the command line. The path will be also added to the dependencies returned by // RuleBuilder.Tools. func (c *RuleBuilderCommand) Tool(path Path) *RuleBuilderCommand { c.tools = append(c.tools, path) return c.Text(path.String()) } // Input adds the specified input path to the command line. The path will also be added to the dependencies returned by // RuleBuilder.Inputs. func (c *RuleBuilderCommand) Input(path Path) *RuleBuilderCommand { c.inputs = append(c.inputs, path) return c.Text(path.String()) } // Inputs adds the specified input paths to the command line, separated by spaces. The paths will also be added to the // dependencies returned by RuleBuilder.Inputs. func (c *RuleBuilderCommand) Inputs(paths Paths) *RuleBuilderCommand { for _, path := range paths { c.Input(path) } return c } // Implicit adds the specified input path to the dependencies returned by RuleBuilder.Inputs without modifying the // command line. func (c *RuleBuilderCommand) Implicit(path Path) *RuleBuilderCommand { c.inputs = append(c.inputs, path) return c } // Implicits adds the specified input paths to the dependencies returned by RuleBuilder.Inputs without modifying the // command line. func (c *RuleBuilderCommand) Implicits(paths Paths) *RuleBuilderCommand { c.inputs = append(c.inputs, paths...) return c } // Output adds the specified output path to the command line. The path will also be added to the outputs returned by // RuleBuilder.Outputs. func (c *RuleBuilderCommand) Output(path WritablePath) *RuleBuilderCommand { c.outputs = append(c.outputs, path) return c.Text(path.String()) } // Outputs adds the specified output paths to the command line, separated by spaces. The paths will also be added to // the outputs returned by RuleBuilder.Outputs. func (c *RuleBuilderCommand) Outputs(paths WritablePaths) *RuleBuilderCommand { for _, path := range paths { c.Output(path) } return c } // DepFile adds the specified depfile path to the paths returned by RuleBuilder.DepFiles and adds it to the command // line, and causes RuleBuilder.Build file to set the depfile flag for ninja. If multiple depfiles are added to // commands in a single RuleBuilder then RuleBuilder.Build will add an extra command to merge the depfiles together. func (c *RuleBuilderCommand) DepFile(path WritablePath) *RuleBuilderCommand { c.depFiles = append(c.depFiles, path) return c.Text(path.String()) } // ImplicitOutput adds the specified output path to the dependencies returned by RuleBuilder.Outputs without modifying // the command line. func (c *RuleBuilderCommand) ImplicitOutput(path WritablePath) *RuleBuilderCommand { c.outputs = append(c.outputs, path) return c } // ImplicitOutputs adds the specified output paths to the dependencies returned by RuleBuilder.Outputs without modifying // the command line. func (c *RuleBuilderCommand) ImplicitOutputs(paths WritablePaths) *RuleBuilderCommand { c.outputs = append(c.outputs, paths...) return c } // ImplicitDepFile adds the specified depfile path to the paths returned by RuleBuilder.DepFiles without modifying // the command line, and causes RuleBuilder.Build file to set the depfile flag for ninja. If multiple depfiles // are added to commands in a single RuleBuilder then RuleBuilder.Build will add an extra command to merge the // depfiles together. func (c *RuleBuilderCommand) ImplicitDepFile(path WritablePath) *RuleBuilderCommand { c.depFiles = append(c.depFiles, path) return c } // FlagWithInput adds the specified flag and input path to the command line, with no separator between them. The path // will also be added to the dependencies returned by RuleBuilder.Inputs. func (c *RuleBuilderCommand) FlagWithInput(flag string, path Path) *RuleBuilderCommand { c.inputs = append(c.inputs, path) return c.Text(flag + path.String()) } // FlagWithInputList adds the specified flag and input paths to the command line, with the inputs joined by sep // and no separator between the flag and inputs. The input paths will also be added to the dependencies returned by // RuleBuilder.Inputs. func (c *RuleBuilderCommand) FlagWithInputList(flag string, paths Paths, sep string) *RuleBuilderCommand { c.inputs = append(c.inputs, paths...) return c.FlagWithList(flag, paths.Strings(), sep) } // FlagForEachInput adds the specified flag joined with each input path to the command line. The input paths will also // be added to the dependencies returned by RuleBuilder.Inputs. The result is identical to calling FlagWithInput for // each input path. func (c *RuleBuilderCommand) FlagForEachInput(flag string, paths Paths) *RuleBuilderCommand { for _, path := range paths { c.FlagWithInput(flag, path) } return c } // FlagWithOutput adds the specified flag and output path to the command line, with no separator between them. The path // will also be added to the outputs returned by RuleBuilder.Outputs. func (c *RuleBuilderCommand) FlagWithOutput(flag string, path WritablePath) *RuleBuilderCommand { c.outputs = append(c.outputs, path) return c.Text(flag + path.String()) } // FlagWithDepFile adds the specified flag and depfile path to the command line, with no separator between them. The path // will also be added to the outputs returned by RuleBuilder.Outputs. func (c *RuleBuilderCommand) FlagWithDepFile(flag string, path WritablePath) *RuleBuilderCommand { c.depFiles = append(c.depFiles, path) return c.Text(flag + path.String()) } // String returns the command line. func (c *RuleBuilderCommand) String() string { return string(c.buf) } func ninjaNameEscape(s string) string { b := []byte(s) escaped := false for i, c := range b { valid := (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || (c == '_') || (c == '-') || (c == '.') if !valid { b[i] = '_' escaped = true } } if escaped { s = string(b) } return s }