123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253 |
- // Copyright 2017 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 (
- "strings"
- "android/soong/bazel"
- "github.com/google/blueprint"
- "github.com/google/blueprint/proptools"
- )
- const (
- canonicalPathFromRootDefault = true
- )
- // TODO(ccross): protos are often used to communicate between multiple modules. If the only
- // way to convert a proto to source is to reference it as a source file, and external modules cannot
- // reference source files in other modules, then every module that owns a proto file will need to
- // export a library for every type of external user (lite vs. full, c vs. c++ vs. java). It would
- // be better to support a proto module type that exported a proto file along with some include dirs,
- // and then external modules could depend on the proto module but use their own settings to
- // generate the source.
- type ProtoFlags struct {
- Flags []string
- CanonicalPathFromRoot bool
- Dir ModuleGenPath
- SubDir ModuleGenPath
- OutTypeFlag string
- OutParams []string
- Deps Paths
- }
- type protoDependencyTag struct {
- blueprint.BaseDependencyTag
- name string
- }
- var ProtoPluginDepTag = protoDependencyTag{name: "plugin"}
- func ProtoDeps(ctx BottomUpMutatorContext, p *ProtoProperties) {
- if String(p.Proto.Plugin) != "" && String(p.Proto.Type) != "" {
- ctx.ModuleErrorf("only one of proto.type and proto.plugin can be specified.")
- }
- if plugin := String(p.Proto.Plugin); plugin != "" {
- ctx.AddFarVariationDependencies(ctx.Config().BuildOSTarget.Variations(),
- ProtoPluginDepTag, "protoc-gen-"+plugin)
- }
- }
- func GetProtoFlags(ctx ModuleContext, p *ProtoProperties) ProtoFlags {
- var flags []string
- var deps Paths
- if len(p.Proto.Local_include_dirs) > 0 {
- localProtoIncludeDirs := PathsForModuleSrc(ctx, p.Proto.Local_include_dirs)
- flags = append(flags, JoinWithPrefix(localProtoIncludeDirs.Strings(), "-I"))
- }
- if len(p.Proto.Include_dirs) > 0 {
- rootProtoIncludeDirs := PathsForSource(ctx, p.Proto.Include_dirs)
- flags = append(flags, JoinWithPrefix(rootProtoIncludeDirs.Strings(), "-I"))
- }
- ctx.VisitDirectDepsWithTag(ProtoPluginDepTag, func(dep Module) {
- if hostTool, ok := dep.(HostToolProvider); !ok || !hostTool.HostToolPath().Valid() {
- ctx.PropertyErrorf("proto.plugin", "module %q is not a host tool provider",
- ctx.OtherModuleName(dep))
- } else {
- plugin := String(p.Proto.Plugin)
- deps = append(deps, hostTool.HostToolPath().Path())
- flags = append(flags, "--plugin=protoc-gen-"+plugin+"="+hostTool.HostToolPath().String())
- }
- })
- var protoOutFlag string
- if plugin := String(p.Proto.Plugin); plugin != "" {
- protoOutFlag = "--" + plugin + "_out"
- }
- return ProtoFlags{
- Flags: flags,
- Deps: deps,
- OutTypeFlag: protoOutFlag,
- CanonicalPathFromRoot: proptools.BoolDefault(p.Proto.Canonical_path_from_root, canonicalPathFromRootDefault),
- Dir: PathForModuleGen(ctx, "proto"),
- SubDir: PathForModuleGen(ctx, "proto", ctx.ModuleDir()),
- }
- }
- type ProtoProperties struct {
- Proto struct {
- // Proto generator type. C++: full or lite. Java: micro, nano, stream, or lite.
- Type *string `android:"arch_variant"`
- // Proto plugin to use as the generator. Must be a cc_binary_host module.
- Plugin *string `android:"arch_variant"`
- // list of directories that will be added to the protoc include paths.
- Include_dirs []string
- // list of directories relative to the bp file that will
- // be added to the protoc include paths.
- Local_include_dirs []string
- // whether to identify the proto files from the root of the
- // source tree (the original method in Android, useful for
- // android-specific protos), or relative from where they were
- // specified (useful for external/third party protos).
- //
- // This defaults to true today, but is expected to default to
- // false in the future.
- Canonical_path_from_root *bool
- } `android:"arch_variant"`
- }
- func ProtoRule(rule *RuleBuilder, protoFile Path, flags ProtoFlags, deps Paths,
- outDir WritablePath, depFile WritablePath, outputs WritablePaths) {
- var protoBase string
- if flags.CanonicalPathFromRoot {
- protoBase = "."
- } else {
- rel := protoFile.Rel()
- protoBase = strings.TrimSuffix(protoFile.String(), rel)
- }
- rule.Command().
- BuiltTool("aprotoc").
- FlagWithArg(flags.OutTypeFlag+"=", strings.Join(flags.OutParams, ",")+":"+outDir.String()).
- FlagWithDepFile("--dependency_out=", depFile).
- FlagWithArg("-I ", protoBase).
- Flags(flags.Flags).
- Input(protoFile).
- Implicits(deps).
- ImplicitOutputs(outputs)
- rule.Command().
- BuiltTool("dep_fixer").Flag(depFile.String())
- }
- // Bp2buildProtoInfo contains information necessary to pass on to language specific conversion.
- type Bp2buildProtoInfo struct {
- Type *string
- Name string
- Proto_libs bazel.LabelList
- }
- type ProtoAttrs struct {
- Srcs bazel.LabelListAttribute
- Strip_import_prefix *string
- Deps bazel.LabelListAttribute
- }
- // For each package in the include_dirs property a proto_library target should
- // be added to the BUILD file in that package and a mapping should be added here
- var includeDirsToProtoDeps = map[string]string{
- "external/protobuf/src": "//external/protobuf:libprotobuf-proto",
- }
- // Bp2buildProtoProperties converts proto properties, creating a proto_library and returning the
- // information necessary for language-specific handling.
- func Bp2buildProtoProperties(ctx Bp2buildMutatorContext, m *ModuleBase, srcs bazel.LabelListAttribute) (Bp2buildProtoInfo, bool) {
- var info Bp2buildProtoInfo
- if srcs.IsEmpty() {
- return info, false
- }
- var protoLibraries bazel.LabelList
- var directProtoSrcs bazel.LabelList
- // For filegroups that should be converted to proto_library just collect the
- // labels of converted proto_library targets.
- for _, protoSrc := range srcs.Value.Includes {
- src := protoSrc.OriginalModuleName
- if fg, ok := ToFileGroupAsLibrary(ctx, src); ok &&
- fg.ShouldConvertToProtoLibrary(ctx) {
- protoLibraries.Add(&bazel.Label{
- Label: fg.GetProtoLibraryLabel(ctx),
- })
- } else {
- directProtoSrcs.Add(&protoSrc)
- }
- }
- info.Name = m.Name() + "_proto"
- if len(directProtoSrcs.Includes) > 0 {
- attrs := ProtoAttrs{
- Srcs: bazel.MakeLabelListAttribute(directProtoSrcs),
- }
- attrs.Deps.Append(bazel.MakeLabelListAttribute(protoLibraries))
- for axis, configToProps := range m.GetArchVariantProperties(ctx, &ProtoProperties{}) {
- for _, rawProps := range configToProps {
- var props *ProtoProperties
- var ok bool
- if props, ok = rawProps.(*ProtoProperties); !ok {
- ctx.ModuleErrorf("Could not cast ProtoProperties to expected type")
- }
- if axis == bazel.NoConfigAxis {
- info.Type = props.Proto.Type
- if !proptools.BoolDefault(props.Proto.Canonical_path_from_root, canonicalPathFromRootDefault) {
- // an empty string indicates to strips the package path
- path := ""
- attrs.Strip_import_prefix = &path
- }
- for _, dir := range props.Proto.Include_dirs {
- if dep, ok := includeDirsToProtoDeps[dir]; ok {
- attrs.Deps.Add(bazel.MakeLabelAttribute(dep))
- } else {
- ctx.PropertyErrorf("Could not find the proto_library target for include dir", dir)
- }
- }
- } else if props.Proto.Type != info.Type && props.Proto.Type != nil {
- ctx.ModuleErrorf("Cannot handle arch-variant types for protos at this time.")
- }
- }
- }
- tags := ApexAvailableTagsWithoutTestApexes(ctx.(TopDownMutatorContext), ctx.Module())
- ctx.CreateBazelTargetModule(
- bazel.BazelTargetModuleProperties{Rule_class: "proto_library"},
- CommonAttributes{Name: info.Name, Tags: tags},
- &attrs,
- )
- protoLibraries.Add(&bazel.Label{
- Label: ":" + info.Name,
- })
- }
- info.Proto_libs = protoLibraries
- return info, true
- }
|