wayland_protocol_codegen.go

// 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
}