103 lines
3.5 KiB
Go
103 lines
3.5 KiB
Go
// 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 (
|
|
"github.com/google/blueprint"
|
|
)
|
|
|
|
func init() {
|
|
pctx.HostBinToolVariable("protocCmd", "aprotoc")
|
|
}
|
|
|
|
var (
|
|
proto = pctx.AndroidStaticRule("protoc",
|
|
blueprint.RuleParams{
|
|
Command: "$protocCmd $protoOut=$protoOutFlags:$outDir $protoFlags $in",
|
|
CommandDeps: []string{"$protocCmd"},
|
|
}, "protoFlags", "protoOut", "protoOutFlags", "outDir")
|
|
)
|
|
|
|
// 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.
|
|
|
|
func GenProto(ctx ModuleContext, protoFile Path,
|
|
protoFlags string, protoOut, protoOutFlags string, extensions []string) WritablePaths {
|
|
|
|
var outFiles WritablePaths
|
|
for _, ext := range extensions {
|
|
outFiles = append(outFiles, GenPathWithExt(ctx, "proto", protoFile, ext))
|
|
}
|
|
|
|
ctx.ModuleBuild(pctx, ModuleBuildParams{
|
|
Rule: proto,
|
|
Description: "protoc " + protoFile.Rel(),
|
|
Outputs: outFiles,
|
|
Input: protoFile,
|
|
Args: map[string]string{
|
|
"outDir": ProtoDir(ctx).String(),
|
|
"protoOut": protoOut,
|
|
"protoOutFlags": protoOutFlags,
|
|
"protoFlags": protoFlags,
|
|
},
|
|
})
|
|
|
|
return outFiles
|
|
}
|
|
|
|
func ProtoFlags(ctx ModuleContext, p *ProtoProperties) []string {
|
|
var protoFlags []string
|
|
if len(p.Proto.Local_include_dirs) > 0 {
|
|
localProtoIncludeDirs := PathsForModuleSrc(ctx, p.Proto.Local_include_dirs)
|
|
protoFlags = append(protoFlags, JoinWithPrefix(localProtoIncludeDirs.Strings(), "-I"))
|
|
}
|
|
if len(p.Proto.Include_dirs) > 0 {
|
|
rootProtoIncludeDirs := PathsForSource(ctx, p.Proto.Include_dirs)
|
|
protoFlags = append(protoFlags, JoinWithPrefix(rootProtoIncludeDirs.Strings(), "-I"))
|
|
}
|
|
|
|
protoFlags = append(protoFlags, "-I .")
|
|
|
|
return protoFlags
|
|
}
|
|
|
|
// ProtoDir returns the module's "gen/proto" directory
|
|
func ProtoDir(ctx ModuleContext) ModuleGenPath {
|
|
return PathForModuleGen(ctx, "proto")
|
|
}
|
|
|
|
// ProtoSubDir returns the module's "gen/proto/path/to/module" directory
|
|
func ProtoSubDir(ctx ModuleContext) ModuleGenPath {
|
|
return 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"`
|
|
|
|
// 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
|
|
} `android:"arch_variant"`
|
|
}
|