blob: 632906ddca6ad4f4078251f9cf789c593d7b1795 [file] [log] [blame]
// Copyright (C) 2017 The Android Open Source Project
//
// 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 wayland_protcool defines extension modules for the Soong build system
// to make it easier to generate code from a list of Wayland protocol files.
//
// The primary extension module is "wayland_protocol_codegen", which applies a
// code generation tool to a list of source protocol files.
//
// Note that the code generation done here is similar to what is done by the
// base Soong "gensrcs" module, but there are two functional differences:
//
// 1) The output filenames are computed from the input filenames, rather
// than needing to be specified explicitly. An optional prefix as well
// as a suffix can be added to the protocol filename (without extension).
//
// 2) Code generation is done for each file independently by emitting
// multiple Ninja build commands, rather than one build command which
// does it all.
package wayland_protocol
import (
"fmt"
"strings"
"github.com/google/blueprint"
"github.com/google/blueprint/proptools"
"android/soong/android"
"android/soong/genrule"
)
func init() {
// Register out extension module type name with Soong.
android.RegisterModuleType(
"wayland_protocol_codegen", waylandCodegenModuleFactory)
}
var (
// Create a context for build rule output from this package
pctx = android.NewPackageContext("android/soong/external/wayland-protocol")
)
type hostToolDependencyTag struct {
blueprint.BaseDependencyTag
}
var hostToolDepTag hostToolDependencyTag
// waylandCodegenProperties defines the properties that will be read in from the
// Android.bp file for each instantiation of the module.
type waylandCodegenProperties struct {
// This string gives the command line template to run on each protocol file
// to wayland_protocol_codegen.
//
// The string can contain one or more "$" prefixed variable names for
// values that can vary. At a minimum you need to use ${location}, ${out}
// and ${in}
//
// $(location): the path to the first entry in tools or tool_files
// $(location <label>): the path to the tool or tool_file with name <label>
// $(in): A protocol file from srcs
// $(out): The constructed output filename from the protocol filename.
// $$: a literal $
Cmd *string
// The string to prepend to every protcol filename to generate the
// corresponding output filename. The empty string by default.
Prefix *string
// The suffix to append to every protocol filename to generate the
// corresponding output filename. The empty string by default.
Suffix *string
// The list of protocol files to process.
Srcs []string
// The names of any built host executables to use for code generation. Can
// be left empty if a local script is used instead (specified in
// tool_files).
Tools []string
// Local files that are used for code generation. Can be scripts to run, but
// should also include any other files that the code generation step should
// depend on that might be used by the code gen tool.
Tool_files []string
}
// waylandGenModule defines the Soong module for each instance.
type waylandGenModule struct {
android.ModuleBase
// Store a copy of the parsed properties for easy reference.
properties waylandCodegenProperties
// Each module emits its own blueprint (Ninja) rule. Store a reference
// to the one created for this instance.
rule blueprint.Rule
// Each module exports one or more include directories. Store the paths here
// here for easy retrieval.
exportedIncludeDirs android.Paths
// Each module has a list of files it outputs, that can be used by other
// modules. Store the list of paths here for easy reference.
outputFiles android.Paths
}
// For the uninitiated, this is an idiom to check that a given object implements
// an interface. In this case we want to be sure that waylandGenModule
// implements genrule.SourceFileGenerator
var _ genrule.SourceFileGenerator = (*waylandGenModule)(nil)
// Check that we implement android.SourceFileProducer
var _ android.SourceFileProducer = (*waylandGenModule)(nil)
// GeneratedSourceFiles implements the genrule.SourceFileGenerator
// GeneratedSourceFiles method to return the list of generated source files.
func (g *waylandGenModule) GeneratedSourceFiles() android.Paths {
return g.outputFiles
}
// GeneratedHeaderDirs implements the genrule.SourceFileGenerator
// GeneratedHeaderDirs method to return the list of exported include
// directories.
func (g *waylandGenModule) GeneratedHeaderDirs() android.Paths {
return g.exportedIncludeDirs
}
// GeneratedDeps implements the genrule.SourceFileGenerator GeneratedDeps
// method to return the list of files to be used as dependencies when using
// GeneratedHeaderDirs.
func (g *waylandGenModule) GeneratedDeps() android.Paths {
return g.outputFiles
}
// Srcs implements the android.SourceFileProducer Srcs method to return the list
// of source files.
func (g *waylandGenModule) Srcs() android.Paths {
return g.outputFiles
}
// DepsMutator implements the android.Module DepsMutator method to apply a
// mutator context to the build graph.
func (g *waylandGenModule) DepsMutator(ctx android.BottomUpMutatorContext) {
// This implementatoin duplicates the one from genrule.go, where gensrcs is
// defined.
android.ExtractSourcesDeps(ctx, g.properties.Srcs)
if g, ok := ctx.Module().(*waylandGenModule); ok {
if len(g.properties.Tools) > 0 {
ctx.AddFarVariationDependencies([]blueprint.Variation{
{"arch", ctx.AConfig().BuildOsVariant},
}, hostToolDepTag, g.properties.Tools...)
}
}
}
// GenerateAndroidBuildActions implements the android.Module
// GenerateAndroidBuildActions method, which generates all the rules and builds
// commands used by this module instance.
func (g *waylandGenModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
if len(g.properties.Tools) == 0 && len(g.properties.Tool_files) == 0 {
ctx.ModuleErrorf("at least one `tools` or `tool_files` is required")
return
}
// Prepare the list of tools that were defined for codegen purposes.
tools, implicitDeps := g.prepareTools(ctx)
if ctx.Failed() {
return
}
// Emit the rule for generating for processing each source file
g.emitRule(ctx, tools)
if ctx.Failed() {
return
}
generatedFilenamePrefix := proptools.String(g.properties.Prefix)
generatedFilenameSuffix := proptools.String(g.properties.Suffix)
for _, src := range ctx.ExpandSources(g.properties.Srcs, nil) {
out := g.generateOutputPath(ctx, src, generatedFilenamePrefix, generatedFilenameSuffix)
if out == nil {
continue
}
g.emitBuild(ctx, src, out, implicitDeps)
g.outputFiles = append(g.outputFiles, out)
}
g.exportedIncludeDirs = append(g.exportedIncludeDirs, android.PathForModuleGen(ctx))
}
// genrateOutputPath takes an source path, a prefix, and a suffix, and use them
// to generate and return corresponding an output file path.
func (g *waylandGenModule) generateOutputPath(ctx android.ModuleContext, src android.Path, prefix string, suffix string) android.WritablePath {
// Construct a new filename by adding the requested prefix and suffix for this
// code generator instance. If the input file name is "wayland.xml", and the
// properties specify a prefix of "test-" and a suffix of "-client.cpp", we
// will end up with a fulename of "test-wayland-client.cpp"
protocolFilename, protocolExt := splitExt(src.Base())
if protocolExt != ".xml" {
ctx.ModuleErrorf("Source file %q does not end with .xml", src)
return nil
}
return android.PathForModuleGen(ctx, prefix+protocolFilename+suffix)
}
// emitRule is an internal function to emit each Ninja rule.
func (g *waylandGenModule) emitRule(ctx android.ModuleContext, tools map[string]android.Path) {
// Get the command to run to process each protocol file. Since everything
// should be templated, we generate a Ninja rule that uses the command,
// and invoke it from each Ninja build command we emit.
g.rule = ctx.Rule(pctx, "generator", blueprint.RuleParams{
Command: g.expandCmd(ctx, tools),
})
}
// emitBuild is an internal function to emit each Build command.
func (g *waylandGenModule) emitBuild(ctx android.ModuleContext, src android.Path, out android.WritablePath, implicitDeps android.Paths) android.Path {
ctx.Build(pctx, android.BuildParams{
Rule: g.rule,
Description: "generate " + out.Base(),
Output: out,
Inputs: android.Paths{src},
Implicits: implicitDeps,
})
return out
}
// prepareTools is an internal function to prepare a list of tools.
func (g *waylandGenModule) prepareTools(ctx android.ModuleContext) (tools map[string]android.Path, implicitDeps android.Paths) {
tools = map[string]android.Path{}
// This was extracted and slightly simplifed from equivalent code in
// genrule.go.
// For each entry in "tool", walk the dependency graph to get more
// information about it.
if len(g.properties.Tools) > 0 {
ctx.VisitDirectDepsBlueprint(func(module blueprint.Module) {
switch ctx.OtherModuleDependencyTag(module) {
case android.SourceDepTag:
// Nothing to do
case hostToolDepTag:
tool := ctx.OtherModuleName(module)
var path android.OptionalPath
if t, ok := module.(genrule.HostToolProvider); ok {
if !t.(android.Module).Enabled() {
if ctx.AConfig().AllowMissingDependencies() {
ctx.AddMissingDependencies([]string{tool})
} else {
ctx.ModuleErrorf("depends on disabled module %q", tool)
}
break
}
path = t.HostToolPath()
} else {
ctx.ModuleErrorf("%q is not a host tool provider", tool)
break
}
if path.Valid() {
implicitDeps = append(implicitDeps, path.Path())
if _, exists := tools[tool]; !exists {
tools[tool] = path.Path()
} else {
ctx.ModuleErrorf("multiple tools for %q, %q and %q", tool, tools[tool], path.Path().String())
}
} else {
ctx.ModuleErrorf("host tool %q missing output file", tool)
}
default:
ctx.ModuleErrorf("unknown dependency on %q", ctx.OtherModuleName(module))
}
})
}
// Get more information about each entry in "tool_files".
for _, tool := range g.properties.Tool_files {
toolPath := android.PathForModuleSrc(ctx, tool)
implicitDeps = append(implicitDeps, toolPath)
if _, exists := tools[tool]; !exists {
tools[tool] = toolPath
} else {
ctx.ModuleErrorf("multiple tools for %q, %q and %q", tool, tools[tool], toolPath.String())
}
}
return
}
// expandCmd is an internal function to do some expansion and any additional
// wrapping of the generator command line. Returns the command line to use and
// an error value.
func (g *waylandGenModule) expandCmd(ctx android.ModuleContext, tools map[string]android.Path) (cmd string) {
cmd, err := android.Expand(proptools.String(g.properties.Cmd), func(name string) (string, error) {
switch name {
case "in":
return "$in", nil
case "out":
// We need to use the sandbox out path instead
//return "$sandboxOut", nil
return "$out", nil
case "location":
if len(g.properties.Tools) > 0 {
return tools[g.properties.Tools[0]].String(), nil
} else {
return tools[g.properties.Tool_files[0]].String(), nil
}
default:
if strings.HasPrefix(name, "location ") {
label := strings.TrimSpace(strings.TrimPrefix(name, "location "))
if tool, ok := tools[label]; ok {
return tool.String(), nil
} else {
return "", fmt.Errorf("unknown location label %q", label)
}
}
return "", fmt.Errorf("unknown variable '$(%s)'", name)
}
})
if err != nil {
ctx.PropertyErrorf("cmd", "%s", err.Error())
}
return
}
// waylandCodegenModuleFactory creates an extension module instance.
func waylandCodegenModuleFactory() android.Module {
m := &waylandGenModule{}
m.AddProperties(&m.properties)
android.InitAndroidModule(m)
return m
}
// splitExt splits a base filename into (filename, ext) components, such that
// input == filename + ext
func splitExt(input string) (filename string, ext string) {
// There is no filepath.SplitExt() or equivalent.
dot := strings.LastIndex(input, ".")
if dot != -1 {
ext = input[dot:]
filename = input[:dot]
} else {
ext = ""
filename = input
}
return
}