684 lines
22 KiB
Plaintext
684 lines
22 KiB
Plaintext
# Copyright 2014 The Chromium Authors
|
|
# Use of this source code is governed by a BSD-style license that can be
|
|
# found in the LICENSE file.
|
|
|
|
# Compile a protocol buffer.
|
|
#
|
|
# Protobuf parameters:
|
|
#
|
|
# proto_in_dir (optional)
|
|
# Specifies the path relative to the current BUILD.gn file where
|
|
# proto files are located and the directory structure of
|
|
# this proto library starts.
|
|
#
|
|
# This option can be calculated automatically but it will raise an
|
|
# assertion error if any nested directories are found.
|
|
#
|
|
# proto_out_dir (optional)
|
|
# Specifies the path suffix that output files are generated under.
|
|
# This path will be appended to |root_gen_dir|, but for python stubs
|
|
# it will be appended to |root_build_dir|/pyproto.
|
|
#
|
|
# generate_python (optional, default true)
|
|
# Generate Python protobuf stubs.
|
|
#
|
|
# generate_cc (optional, default true)
|
|
# Generate C++ protobuf stubs.
|
|
#
|
|
# generate_javascript (optional, default false)
|
|
# Generate Javascript protobuf stubs.
|
|
#
|
|
# generate_library (optional, default true)
|
|
# Generate a "static_library" target for linking with the generated code.
|
|
#
|
|
# generate_py_runtime (optional, default false)
|
|
# Generates a "_py_runtime"-suffixed target for test targets that need the
|
|
# Python stubs available at runtime.
|
|
#
|
|
# cc_generator_options (optional)
|
|
# List of extra flags passed to the protocol compiler. If you need to
|
|
# add an EXPORT macro to a protobuf's C++ header, set the
|
|
# 'cc_generator_options' variable with the value:
|
|
# 'dllexport_decl=FOO_EXPORT:' (note trailing colon).
|
|
#
|
|
# It is likely you also need to #include a file for the above EXPORT
|
|
# macro to work (see cc_include) and set
|
|
# component_build_force_source_set = true.
|
|
#
|
|
# cc_include (optional)
|
|
# String listing an extra include that should be passed.
|
|
# Example: cc_include = "foo/bar.h"
|
|
#
|
|
# generator_plugin_label (optional)
|
|
# GN label for plugin executable which generates custom cc stubs.
|
|
# Don't specify a toolchain, host toolchain is assumed.
|
|
#
|
|
# generator_plugin_script (optional)
|
|
# Path to plugin script. Mutually exclusive with |generator_plugin_label|.
|
|
#
|
|
# generator_plugin_script_deps (optional)
|
|
# List of additional files required for generator plugin script.
|
|
#
|
|
# generator_plugin_suffix[es] (required if using a plugin)
|
|
# Suffix (before extension) for generated .cc and .h files
|
|
# or list of suffixes for all files (with extensions).
|
|
#
|
|
# generator_plugin_options (optional)
|
|
# Extra flags passed to the plugin. See cc_generator_options.
|
|
#
|
|
# deps (optional)
|
|
# DEPRECATED: use proto_deps or link_deps instead (crbug.com/938011).
|
|
# Additional dependencies.
|
|
#
|
|
# link_deps (optional)
|
|
# Additional dependencies linked to library.
|
|
#
|
|
# proto_deps (optional)
|
|
# Additional dependencies required before running protoc.
|
|
# e.g. proto file generating action.
|
|
#
|
|
# use_protobuf_full (optional)
|
|
# If adding protobuf library would be required, adds protobuf_full to deps
|
|
# instead of protobuf_lite.
|
|
#
|
|
# import_dirs (optional)
|
|
# A list of extra import directories to be passed to protoc compiler.
|
|
# WARNING: This circumvents proto checkdeps, and should only be used when
|
|
# needed, typically when proto files cannot cleanly import through
|
|
# absolute paths, such as for third_party or generated .proto files.
|
|
# http://crbug.com/691451 tracks fixing this.
|
|
#
|
|
# Parameters for compiling the generated code:
|
|
#
|
|
# force_source_set (Default=false)
|
|
# When set true the generated code will be compiled as a source set.
|
|
# This can be useful if you need to export the generated symbols from a
|
|
# shared library. You should use this carefully, as you probably only
|
|
# want this if your dependencies are *always* shared libraries. Most
|
|
# of the time, you probably want `component_build_force_source_set`
|
|
# instead (see the next option).
|
|
# component_build_force_source_set (Default=false)
|
|
# When set true the generated code will be compiled as a source set in
|
|
# the component build. This does not affect static builds. If you are
|
|
# exporting symbols from a component, this is required to prevent those
|
|
# symbols from being stripped. If you're not using dllexports in
|
|
# cc_generator_options, it's usually best to leave this false.
|
|
#
|
|
# defines (optional)
|
|
# Defines to supply to the source set that compiles the generated source
|
|
# code.
|
|
#
|
|
# extra_configs (optional)
|
|
# A list of config labels that will be appended to the configs applying
|
|
# to the source set.
|
|
#
|
|
# remove_configs (optional)
|
|
# A list of config labels that will be removed from the configs apllying
|
|
# to the source set.
|
|
#
|
|
# propagate_imports_configs (optional)
|
|
# A boolean value (defaults to true) that specifies whether the config
|
|
# generated for the library's import directories will be propagated to
|
|
# dependents as one of the library target's public_configs. See
|
|
# crbug.com/1043279#c11 and crbug.com/gn/142 for why this option exists.
|
|
# WARNING: If set to false, the embedder target is responsible for
|
|
# propagating a suitable config, so that any dependent headers can resolve
|
|
# includes generated by proto imports.
|
|
#
|
|
# Example:
|
|
# proto_library("mylib") {
|
|
# sources = [
|
|
# "foo.proto",
|
|
# ]
|
|
# }
|
|
|
|
import("//build/config/sanitizers/sanitizers.gni")
|
|
import("//build/toolchain/kythe.gni")
|
|
|
|
declare_args() {
|
|
# Allows subprojects to omit javascript dependencies (e.g.) closure_compiler
|
|
# and google-closure-library.
|
|
enable_js_protobuf = true
|
|
}
|
|
|
|
if (enable_js_protobuf) {
|
|
import("//third_party/closure_compiler/compile_js.gni")
|
|
}
|
|
|
|
if (host_os == "win") {
|
|
_host_executable_suffix = ".exe"
|
|
} else {
|
|
_host_executable_suffix = ""
|
|
}
|
|
|
|
_protoc_label = "//third_party/protobuf:protoc($host_toolchain)"
|
|
_protoc_path = get_label_info(_protoc_label, "root_out_dir") + "/protoc" +
|
|
_host_executable_suffix
|
|
|
|
template("proto_library") {
|
|
assert(defined(invoker.sources), "Need sources for proto_library")
|
|
proto_sources = invoker.sources
|
|
|
|
if (defined(invoker.generate_cc)) {
|
|
generate_cc = invoker.generate_cc
|
|
} else {
|
|
generate_cc = true
|
|
}
|
|
|
|
if (defined(invoker.generate_python)) {
|
|
generate_python = invoker.generate_python
|
|
} else {
|
|
generate_python = true
|
|
}
|
|
|
|
if (defined(invoker.generate_javascript)) {
|
|
generate_javascript = invoker.generate_javascript
|
|
} else {
|
|
generate_javascript = false
|
|
}
|
|
|
|
if (defined(invoker.generate_descriptor)) {
|
|
generate_descriptor = invoker.generate_descriptor
|
|
} else {
|
|
generate_descriptor = ""
|
|
}
|
|
|
|
if (defined(invoker.generate_py_runtime)) {
|
|
generate_py_runtime = invoker.generate_py_runtime
|
|
} else {
|
|
generate_py_runtime = false
|
|
}
|
|
if (generate_py_runtime) {
|
|
generate_python = true
|
|
}
|
|
|
|
# exclude_imports is only used for generating the descriptor. Therefore, the
|
|
# check needs to be here to avoid complaints from GN about the unused
|
|
# variable.
|
|
if (generate_descriptor != "") {
|
|
if (defined(invoker.exclude_imports)) {
|
|
exclude_imports = invoker.exclude_imports
|
|
} else {
|
|
exclude_imports = false
|
|
}
|
|
}
|
|
|
|
if (defined(invoker.generator_plugin_label)) {
|
|
# Straightforward way to get the name of executable doesn't work because
|
|
# |root_out_dir| and |root_build_dir| may differ in cross-compilation and
|
|
# also Windows executables have .exe at the end.
|
|
|
|
plugin_host_label = invoker.generator_plugin_label + "($host_toolchain)"
|
|
plugin_path =
|
|
get_label_info(plugin_host_label, "root_out_dir") + "/" +
|
|
get_label_info(plugin_host_label, "name") + _host_executable_suffix
|
|
generate_with_plugin = true
|
|
} else if (defined(invoker.generator_plugin_script)) {
|
|
plugin_path = invoker.generator_plugin_script
|
|
generate_with_plugin = true
|
|
} else {
|
|
generate_with_plugin = false
|
|
}
|
|
|
|
if (generate_with_plugin) {
|
|
if (defined(invoker.generator_plugin_suffix)) {
|
|
generator_plugin_suffixes = [
|
|
"${invoker.generator_plugin_suffix}.h",
|
|
"${invoker.generator_plugin_suffix}.cc",
|
|
]
|
|
} else {
|
|
generator_plugin_suffixes = invoker.generator_plugin_suffixes
|
|
}
|
|
}
|
|
|
|
if (defined(invoker.proto_in_dir)) {
|
|
proto_in_dir = invoker.proto_in_dir
|
|
has_nested_dirs = false
|
|
foreach(proto_source, proto_sources) {
|
|
if (get_path_info(proto_source, "dir") != proto_in_dir) {
|
|
has_nested_dirs = true
|
|
}
|
|
}
|
|
} else {
|
|
proto_in_dir = get_path_info(proto_sources[0], "dir")
|
|
has_nested_dirs = false
|
|
|
|
# Sanity check, |proto_in_dir| should be defined to allow sub-directories.
|
|
foreach(proto_source, proto_sources) {
|
|
assert(get_path_info(proto_source, "dir") == proto_in_dir,
|
|
"Please define |proto_in_dir| to allow nested directories.")
|
|
}
|
|
}
|
|
|
|
# Avoid absolute path because of the assumption that |proto_in_dir| is
|
|
# relative to the directory of current BUILD.gn file.
|
|
proto_in_dir = rebase_path(proto_in_dir, ".")
|
|
|
|
if (defined(invoker.proto_out_dir)) {
|
|
proto_out_dir = invoker.proto_out_dir
|
|
} else {
|
|
# Absolute path to the directory of current BUILD.gn file excluding "//".
|
|
proto_out_dir = rebase_path(".", "//")
|
|
if (proto_in_dir != ".") {
|
|
proto_out_dir += "/$proto_in_dir"
|
|
}
|
|
}
|
|
|
|
# We need both absolute path to use in GN statements and a relative one
|
|
# to pass to external script.
|
|
if (generate_cc || generate_with_plugin) {
|
|
cc_out_dir = "$root_gen_dir/" + proto_out_dir
|
|
rel_cc_out_dir = rebase_path(cc_out_dir, root_build_dir)
|
|
}
|
|
if (generate_python) {
|
|
py_out_dir = "$root_out_dir/pyproto/" + proto_out_dir
|
|
rel_py_out_dir = rebase_path(py_out_dir, root_build_dir)
|
|
}
|
|
if (generate_javascript) {
|
|
js_out_dir = "$root_out_dir/jsproto/" + proto_out_dir
|
|
rel_js_out_dir = rebase_path(js_out_dir, root_build_dir)
|
|
}
|
|
if (generate_descriptor != "") {
|
|
descriptor_out =
|
|
"$root_gen_dir/" + proto_out_dir + "/" + generate_descriptor
|
|
rel_descriptor_out = rebase_path(descriptor_out, root_build_dir)
|
|
}
|
|
|
|
protos = rebase_path(invoker.sources, proto_in_dir)
|
|
protogens = []
|
|
protogens_py = []
|
|
protogens_cc = []
|
|
protogens_js = []
|
|
|
|
# Whether source code bindings should be generated.
|
|
generate_sources = generate_cc || generate_python || generate_with_plugin ||
|
|
generate_javascript
|
|
|
|
# Whether library should be generated.
|
|
# Library is not needed when proto_library is used to generate binary descriptor, in which case
|
|
# corresponding library target should be omitted entirely.
|
|
if (defined(invoker.generate_library)) {
|
|
generate_library = invoker.generate_library
|
|
} else {
|
|
generate_library = generate_sources
|
|
}
|
|
|
|
# List output files.
|
|
if (generate_sources) {
|
|
foreach(proto, protos) {
|
|
proto_dir = get_path_info(proto, "dir")
|
|
proto_name = get_path_info(proto, "name")
|
|
proto_path = proto_dir + "/" + proto_name
|
|
|
|
if (generate_cc) {
|
|
protogens_cc += [
|
|
"$cc_out_dir/$proto_path.pb.h",
|
|
"$cc_out_dir/$proto_path.pb.cc",
|
|
]
|
|
}
|
|
if (generate_python) {
|
|
protogens_py += [ "$py_out_dir/${proto_path}_pb2.py" ]
|
|
}
|
|
if (generate_with_plugin) {
|
|
foreach(suffix, generator_plugin_suffixes) {
|
|
protogens_cc += [ "$cc_out_dir/${proto_path}${suffix}" ]
|
|
}
|
|
}
|
|
if (generate_javascript) {
|
|
protogens_js += [ "$js_out_dir/${proto_path}.js" ]
|
|
}
|
|
}
|
|
}
|
|
|
|
# If descriptor needs to be generated, it should be added to list of outputs once.
|
|
if (generate_descriptor != "") {
|
|
protogens += [ descriptor_out ]
|
|
}
|
|
|
|
action_name = "${target_name}_gen"
|
|
source_set_name = target_name
|
|
javascript_name = "${target_name}_js"
|
|
py_runtime_name = "${target_name}_py_runtime"
|
|
|
|
# Generate protobuf stubs.
|
|
action(action_name) {
|
|
visibility = [
|
|
":$javascript_name",
|
|
":$py_runtime_name",
|
|
":$source_set_name",
|
|
]
|
|
script = "//tools/protoc_wrapper/protoc_wrapper.py"
|
|
args = protos
|
|
|
|
sources = proto_sources
|
|
outputs =
|
|
get_path_info(protogens + protogens_cc + protogens_js + protogens_py,
|
|
"abspath")
|
|
|
|
if (defined(invoker.testonly)) {
|
|
testonly = invoker.testonly
|
|
}
|
|
|
|
args += [
|
|
# Wrapper should never pick a system protoc.
|
|
# Path should be rebased because |root_build_dir| for current toolchain
|
|
# may be different from |root_out_dir| of protoc built on host toolchain.
|
|
"--protoc",
|
|
"./" + rebase_path(_protoc_path, root_build_dir),
|
|
"--proto-in-dir",
|
|
rebase_path(proto_in_dir, root_build_dir),
|
|
]
|
|
|
|
if (generate_cc) {
|
|
args += [
|
|
"--cc-out-dir",
|
|
rel_cc_out_dir,
|
|
]
|
|
if (enable_kythe_annotations) {
|
|
args += [ "--enable-kythe-annotation" ]
|
|
}
|
|
if (defined(invoker.cc_generator_options)) {
|
|
args += [
|
|
"--cc-options",
|
|
invoker.cc_generator_options,
|
|
]
|
|
}
|
|
if (defined(invoker.cc_include)) {
|
|
args += [
|
|
"--include",
|
|
invoker.cc_include,
|
|
]
|
|
}
|
|
}
|
|
|
|
if (generate_python) {
|
|
args += [
|
|
"--py-out-dir",
|
|
rel_py_out_dir,
|
|
]
|
|
}
|
|
|
|
if (generate_javascript) {
|
|
args += [
|
|
"--js-out-dir",
|
|
rel_js_out_dir,
|
|
]
|
|
}
|
|
|
|
if (generate_with_plugin) {
|
|
args += [
|
|
"--plugin",
|
|
rebase_path(plugin_path, root_build_dir),
|
|
"--plugin-out-dir",
|
|
rel_cc_out_dir,
|
|
]
|
|
if (defined(invoker.generator_plugin_options)) {
|
|
args += [
|
|
"--plugin-options",
|
|
invoker.generator_plugin_options,
|
|
]
|
|
}
|
|
}
|
|
|
|
if (generate_descriptor != "") {
|
|
depfile =
|
|
"$root_gen_dir/" + proto_out_dir + "/" + generate_descriptor + ".d"
|
|
rel_depfile = rebase_path(depfile, root_build_dir)
|
|
|
|
if (exclude_imports) {
|
|
args += [ "--exclude-imports" ]
|
|
}
|
|
|
|
args += [
|
|
"--descriptor-set-out",
|
|
rel_descriptor_out,
|
|
"--descriptor-set-dependency-file",
|
|
rel_depfile,
|
|
]
|
|
}
|
|
|
|
if (defined(invoker.import_dirs)) {
|
|
foreach(path, invoker.import_dirs) {
|
|
args += [ "--import-dir=" + rebase_path(path, root_build_dir) ]
|
|
}
|
|
}
|
|
|
|
# System protoc is not used so it's necessary to build a chromium one.
|
|
inputs = [ _protoc_path ]
|
|
deps = [ _protoc_label ]
|
|
|
|
if (generate_with_plugin) {
|
|
inputs += [ plugin_path ]
|
|
if (defined(invoker.generator_plugin_script_deps)) {
|
|
# Additional scripts for plugin.
|
|
inputs += invoker.generator_plugin_script_deps
|
|
}
|
|
if (defined(plugin_host_label)) {
|
|
# Action depends on native generator plugin but for host toolchain only.
|
|
deps += [ plugin_host_label ]
|
|
}
|
|
}
|
|
|
|
# The deps may have steps that have to run before running protoc.
|
|
if (defined(invoker.proto_deps)) {
|
|
deps += invoker.proto_deps
|
|
}
|
|
if (defined(invoker.deps)) {
|
|
deps += invoker.deps
|
|
}
|
|
}
|
|
|
|
if (!generate_library) {
|
|
# If only descriptor is required, just generate a group wrapper for action output.
|
|
link_target_type = "group"
|
|
} else if ((defined(invoker.force_source_set) && invoker.force_source_set) ||
|
|
(defined(invoker.component_build_force_source_set) &&
|
|
invoker.component_build_force_source_set && is_component_build)) {
|
|
# Option to disable building a library in component build.
|
|
link_target_type = "source_set"
|
|
} else {
|
|
link_target_type = "static_library"
|
|
}
|
|
|
|
# Generated files may include other generated headers. These includes always
|
|
# use relative paths starting at |cc_out_dir|.
|
|
# However there is no necessity to add an additional directory, if all protos
|
|
# are located in the same directory which is in the search path by default.
|
|
config_name = "${target_name}_config"
|
|
config(config_name) {
|
|
include_dirs = []
|
|
if (has_nested_dirs && generate_cc) {
|
|
include_dirs += [ cc_out_dir ]
|
|
}
|
|
if (defined(invoker.import_dirs)) {
|
|
foreach(path, invoker.import_dirs) {
|
|
include_dirs += [ "$root_gen_dir/" + rebase_path(path, "//") ]
|
|
}
|
|
}
|
|
}
|
|
|
|
# Build generated javascript stubs.
|
|
if (generate_javascript) {
|
|
js_library(javascript_name) {
|
|
forward_variables_from(invoker,
|
|
[
|
|
"testonly",
|
|
"visibility",
|
|
])
|
|
|
|
sources = protogens_js
|
|
|
|
deps = [ "//third_party/protobuf:js_proto" ]
|
|
|
|
extra_deps = [ ":$action_name" ]
|
|
}
|
|
}
|
|
|
|
# Build generated protobuf stubs as libary or source set.
|
|
target(link_target_type, target_name) {
|
|
forward_variables_from(invoker,
|
|
[
|
|
"defines",
|
|
"testonly",
|
|
"visibility",
|
|
])
|
|
|
|
if (generate_library) {
|
|
sources = get_path_info(protogens_cc, "abspath")
|
|
|
|
if (defined(invoker.remove_configs)) {
|
|
configs -= invoker.remove_configs
|
|
}
|
|
|
|
if (defined(invoker.extra_configs)) {
|
|
configs += invoker.extra_configs
|
|
}
|
|
|
|
# Remove Sanitizer and coverage instrumentation for a performance boost when
|
|
# fuzzing, since the only fuzzers that use protobuf are libprotobuf-mutator
|
|
# based fuzzers, and they don't actually target protobuf code.
|
|
configs -= not_fuzzed_remove_configs
|
|
configs += [ "//build/config/sanitizers:not_fuzzed" ]
|
|
}
|
|
|
|
public_configs = [
|
|
"//third_party/protobuf:using_proto",
|
|
"//third_party/protobuf:allow_deprecated_proto_fields",
|
|
]
|
|
public_deps = []
|
|
|
|
if (generate_cc || generate_with_plugin) {
|
|
# Not necessary if all protos are located in the same directory.
|
|
if (has_nested_dirs || defined(invoker.import_dirs)) {
|
|
# By default, propagate the config for |include_dirs| to dependent
|
|
# targets, so that public imports can be resolved to corresponding
|
|
# header files. In some cases, the embedder target handles include
|
|
# directory propagation itself, e.g. via a common config.
|
|
propagate_imports_configs =
|
|
!defined(invoker.propagate_imports_configs) ||
|
|
invoker.propagate_imports_configs
|
|
if (propagate_imports_configs) {
|
|
public_configs += [ ":$config_name" ]
|
|
} else {
|
|
# Embedder handles include directory propagation to dependents.
|
|
configs += [ ":$config_name" ]
|
|
}
|
|
}
|
|
|
|
# If using built-in cc generator, the resulting headers reference headers
|
|
# within protobuf_lite. Hence, dependencies require those headers too.
|
|
# If using generator plugin, extra deps should be resolved by the invoker.
|
|
if (generate_cc) {
|
|
if (defined(invoker.use_protobuf_full) &&
|
|
invoker.use_protobuf_full == true) {
|
|
public_deps += [ "//third_party/protobuf:protobuf_full" ]
|
|
} else {
|
|
public_deps += [ "//third_party/protobuf:protobuf_lite" ]
|
|
}
|
|
|
|
if (is_win) {
|
|
cflags = [
|
|
# disable: C4125 decimal digit terminates octal escape sequence
|
|
# Protoc generates such sequences frequently, there's no obvious
|
|
# superior replacement behavior. Since this code is autogenerated,
|
|
# the warning would never catch a legitimate bug.
|
|
"/wd4125",
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
public_deps += [ ":$action_name" ]
|
|
deps = []
|
|
|
|
# This will link any libraries in the deps (the use of invoker.deps in the
|
|
# action won't link it).
|
|
if (defined(invoker.deps)) {
|
|
deps += invoker.deps
|
|
}
|
|
if (defined(invoker.link_deps)) {
|
|
deps += invoker.link_deps
|
|
}
|
|
}
|
|
|
|
if (generate_py_runtime) {
|
|
group(py_runtime_name) {
|
|
data = protogens_py
|
|
deps = [
|
|
":$action_name",
|
|
"//third_party/protobuf:py_proto_runtime",
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
# Convert a protocol buffer between text and binary formats.
|
|
# This can be used to run protoc with the --encode or --decode options.
|
|
# Parameters:
|
|
#
|
|
# sources: list of string
|
|
# The sources to loop over and run protoc on
|
|
#
|
|
# inputs: list of string
|
|
# The file dependencies for the action. This should be the list of .proto
|
|
# files involved in the conversion operation.
|
|
#
|
|
# output_pattern: string
|
|
# A path pattern with source expansion variables (like source_name_part)
|
|
# for where the result of conversion should be placed.
|
|
#
|
|
# deps: (optional) list of label
|
|
# Additional dependencies for the target.
|
|
#
|
|
# args: list of string
|
|
# Arguments to pass to the protoc tool. This could include -I for include
|
|
# paths, as well as the name of the proto file.
|
|
#
|
|
#
|
|
# Example to convert a .textproto to a .binarybp:
|
|
# protoc_convert("convert_foo") {
|
|
# sources = [
|
|
# "test/data/example1.textproto",
|
|
# "test/data/example2.textproto",
|
|
# ]
|
|
# inputs = [
|
|
# "//component/core/foo.proto",
|
|
# ]
|
|
# output_pattern = "$target_gen_dir/foo_data/{{source_name_part}}.binarypb"
|
|
# args = [
|
|
# "--encode=foo.FooMessage",
|
|
# "-I",
|
|
# rebase_path("//"),
|
|
# "component/core/foo.proto",
|
|
# ]
|
|
# }
|
|
template("protoc_convert") {
|
|
action_foreach(target_name) {
|
|
script = "//tools/protoc_wrapper/protoc_convert.py"
|
|
|
|
sources = invoker.sources
|
|
|
|
inputs = invoker.inputs
|
|
|
|
deps = [ _protoc_label ]
|
|
if (defined(invoker.deps)) {
|
|
deps += invoker.deps
|
|
}
|
|
|
|
if (defined(invoker.testonly)) {
|
|
testonly = invoker.testonly
|
|
}
|
|
|
|
outputs = [ invoker.output_pattern ]
|
|
|
|
args = [
|
|
"--protoc",
|
|
"./" + rebase_path(_protoc_path, root_build_dir),
|
|
"--infile",
|
|
"{{source}}",
|
|
"--outfile",
|
|
rebase_path(invoker.output_pattern),
|
|
] + invoker.args
|
|
}
|
|
}
|