# 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.
# This file contains templates for generating static libraries based on the
# corresponding output of the schema compiler tools. The output can be either
# the generated C++ types (generated_types template), the bundled extension
# function registration (json_schema_api template with
# bundle_registration = true), or the bundled JSON strings of the APIs
# (json_schema_api template with bundle = true). The generated library target
# has implicit hard dependencies on all schema files listed by the invoker and
# is itself a hard dependency.
#
# Common variables that can be used in all templates are:
# - sources [required] A list of schema files used to generate the C++ types.
#
# - root_namespace [required]
# A Python string substituion pattern used to generate the C++
# namespace for each API. Use %(namespace)s to replace with the API
# namespace, like "toplevel::%(namespace)s_api".
#
# schema_include_rules [optional]
# A list of paths to include when searching for referenced objects,
# with the namespace separated by a :.
# Example:
# [ '/foo/bar:Foo::Bar::%(namespace)s' ]
#
# - configs [optional]
# Extra gn configs to apply to the compile step.
#
# - deps [optional]
# If any deps are specified they will be inherited by the static library
# target.
#
# - visibility [optional]
# A specific visibility to apply for the generated static library. If
# omitted, visibility will be inherited from the invoker.
# NOTE: Common variables here for when multiple templates use them.
compiler_root = "//tools/json_schema_compiler"
compiler_script = "$compiler_root/compiler.py"
compiler_sources = [
"$compiler_root/cc_generator.py",
"$compiler_root/code_util.py",
"$compiler_root/compiler.py",
"$compiler_root/cpp_bundle_generator.py",
"$compiler_root/cpp_generator.py",
"$compiler_root/cpp_type_generator.py",
"$compiler_root/cpp_util.py",
"$compiler_root/h_generator.py",
"$compiler_root/idl_schema.py",
"$compiler_root/model.py",
"$compiler_root/util_cc_helper.py",
]
# Outputs the bundle of generated JSON strings for each API.
#
# Template-specific variables (in addition to the common ones described above):
#
# bundle_name [required]
# A string to prepend to generated bundle class names, so that multiple
# bundle rules can be used without conflicting. Only used with one of
# the cpp-bundle generators.
#
# root [optional]
# base directory of the source json file(s)
# defaults to "//"
#
# target_prefix [optional]
# subdir below root_gen_dir that is the base directory for the generated
# output files, defaults to empty string (no subdir)
template("generated_json_strings") {
assert(defined(invoker.sources),
"\"sources\" must be defined for the $target_name template.")
assert(defined(invoker.root_namespace),
"\"root_namespace\" must be defined for the $target_name template.")
assert(defined(invoker.bundle_name),
"\"bundle_name\" must be defined for bundles")
assert(!defined(invoker.root) || defined(invoker.target_prefix),
"\"target_prefix\" is required when \"root\" is specified")
schema_include_rules = ""
if (defined(invoker.schema_include_rules)) {
schema_include_rules = invoker.schema_include_rules
}
include_dir = root_gen_dir
destdir = rebase_path(root_gen_dir, root_build_dir)
if (defined(invoker.target_prefix)) {
destdir += "/${invoker.target_prefix}"
include_dir += "/${invoker.target_prefix}"
}
generated_config_name = target_name + "_generated_config"
config(generated_config_name) {
include_dirs = [ include_dir ]
}
root_namespace = invoker.root_namespace
if (defined(invoker.root)) {
root_folder = invoker.root
} else {
root_folder = "//"
}
# Save the target_name, since other targets (like the action() and
# action_foreach() below) need to reference them, but would have their own
# target_name variable.
root_target_name = target_name
bundle_generator_schema_name = target_name + "_bundle_generator_schema"
action(bundle_generator_schema_name) {
visibility = [ ":$root_target_name" ]
script = compiler_script
inputs = compiler_sources + invoker.sources
outputs = [
"$target_gen_dir/generated_schemas.cc",
"$target_gen_dir/generated_schemas.h",
]
args = [
"--root=" + rebase_path(root_folder, root_build_dir),
"--destdir=$destdir",
"--namespace=$root_namespace",
"--bundle-name=" + invoker.bundle_name,
"--generator=cpp-bundle-schema",
"--include-rules=$schema_include_rules",
] + rebase_path(invoker.sources, root_build_dir)
}
# Compute the contents of the library/source set.
lib_sources = get_target_outputs(":$bundle_generator_schema_name")
lib_deps = [ ":$bundle_generator_schema_name" ]
lib_public_deps = [ "//base" ]
lib_extra_configs = []
if (defined(invoker.configs)) {
lib_extra_configs += invoker.configs
}
if (defined(invoker.deps)) {
lib_deps += invoker.deps
}
static_library(target_name) {
sources = lib_sources
deps = lib_deps
public_deps = lib_public_deps
configs += lib_extra_configs
configs += [ "//build/config/compiler:wexit_time_destructors" ]
public_configs = [ ":$generated_config_name" ]
if (defined(invoker.visibility)) {
visibility = invoker.visibility
}
}
}
# Outputs the bundle of extension function registrations.
#
# Template-specific variables (in addition to the common ones described above):
#
# bundle_name [required]
# A string to prepend to generated bundle class names, so that multiple
# bundle rules can be used without conflicting. Only used with one of
# the cpp-bundle generators.
#
# impl_dir [required if bundle_registration = true, otherwise unused]
# The path containing C++ implementations of API functions. This path is
# used as the root path when looking for {schema}/{schema}_api.h headers
# when generating API registration bundles. Such headers, if found, are
# automatically included by the generated code.
#
# root [optional]
# base directory of the source json file(s)
# defaults to "//"
#
# target_prefix [optional]
# subdir below root_gen_dir that is the base directory for the generated
# output files, defaults to empty string (no subdir)
template("function_registration") {
assert(defined(invoker.sources),
"\"sources\" must be defined for the $target_name template.")
assert(defined(invoker.root_namespace),
"\"root_namespace\" must be defined for the $target_name template.")
assert(defined(invoker.bundle_name),
"\"bundle_name\" must be defined for bundle registrations")
assert(defined(invoker.impl_dir),
"\"impl_dir\" must be defined for the $target_name template.")
assert(!defined(invoker.root) || defined(invoker.target_prefix),
"\"target_prefix\" is required when \"root\" is specified")
schema_include_rules = ""
if (defined(invoker.schema_include_rules)) {
schema_include_rules = invoker.schema_include_rules
}
include_dir = root_gen_dir
destdir = rebase_path(root_gen_dir, root_build_dir)
if (defined(invoker.target_prefix)) {
destdir += "/${invoker.target_prefix}"
include_dir += "/${invoker.target_prefix}"
}
generated_config_name = target_name + "_generated_config"
config(generated_config_name) {
include_dirs = [ include_dir ]
}
root_namespace = invoker.root_namespace
# Save the target_name, since other targets (like the action() and
# action_foreach() below) need to reference them, but would have their own
# target_name variable.
root_target_name = target_name
if (defined(invoker.root)) {
root_folder = invoker.root
} else {
root_folder = "//"
}
# Child directory inside the generated file tree.
gen_child_dir = get_path_info(invoker.impl_dir + "/", "gen_dir")
bundle_generator_registration_name =
target_name + "_bundle_generator_registration"
action(bundle_generator_registration_name) {
visibility = [ ":$root_target_name" ]
script = compiler_script
inputs = compiler_sources + invoker.sources
outputs = [
"$gen_child_dir/generated_api_registration.cc",
"$gen_child_dir/generated_api_registration.h",
]
args = [
"--root=" + rebase_path(root_folder, root_build_dir),
"--destdir=$destdir",
"--namespace=$root_namespace",
"--bundle-name=" + invoker.bundle_name,
"--generator=cpp-bundle-registration",
"--impl-dir=" + rebase_path(invoker.impl_dir, root_folder),
"--include-rules=$schema_include_rules",
] + rebase_path(invoker.sources, root_build_dir)
}
# Compute the contents of the library/source set.
lib_sources = get_target_outputs(":$bundle_generator_registration_name")
lib_deps = [ ":$bundle_generator_registration_name" ]
lib_extra_configs = []
if (defined(invoker.configs)) {
lib_extra_configs += invoker.configs
}
if (defined(invoker.deps)) {
lib_deps += invoker.deps
}
static_library(target_name) {
sources = lib_sources
deps = lib_deps
public_deps = []
configs += lib_extra_configs
configs += [ "//build/config/compiler:wexit_time_destructors" ]
public_configs = [ ":$generated_config_name" ]
if (defined(invoker.visibility)) {
visibility = invoker.visibility
}
}
}
# Generates the C++ types for the given APIs.
#
# root [optional]
# base directory of the source json file(s)
# defaults to "//"
#
# target_prefix [optional]
# subdir below root_gen_dir that is the base directory for the generated
# output files, defaults to empty string (no subdir)
template("generated_types") {
assert(defined(invoker.sources),
"\"sources\" must be defined for the $target_name template.")
assert(defined(invoker.root_namespace),
"\"root_namespace\" must be defined for the $target_name template.")
assert(!defined(invoker.root) || defined(invoker.target_prefix),
"\"target_prefix\" is required when \"root\" is specified")
schema_include_rules = ""
if (defined(invoker.schema_include_rules)) {
schema_include_rules = invoker.schema_include_rules
}
include_dir = root_gen_dir
destdir = rebase_path(root_gen_dir, root_build_dir)
if (defined(invoker.target_prefix)) {
destdir += "/${invoker.target_prefix}"
include_dir += "/${invoker.target_prefix}"
}
generated_config_name = target_name + "_generated_config"
config(generated_config_name) {
include_dirs = [ include_dir ]
}
if (defined(invoker.root)) {
root_folder = invoker.root
} else {
root_folder = "//"
}
root_namespace = invoker.root_namespace
# Save the target_name, since other targets (like the action() and
# action_foreach() below) need to reference them, but would have their own
# target_name variable.
root_target_name = target_name
schema_generator_name = target_name + "_schema_generator"
action_foreach(schema_generator_name) {
visibility = [ ":$root_target_name" ]
script = compiler_script
sources = invoker.sources
inputs = compiler_sources
outputs = [
"$target_gen_dir/{{source_name_part}}.cc",
"$target_gen_dir/{{source_name_part}}.h",
]
args = [
"{{source}}",
"--root=" + rebase_path(root_folder, root_build_dir),
"--destdir=$destdir",
"--namespace=$root_namespace",
"--generator=cpp",
"--include-rules=$schema_include_rules",
]
}
# Compute the contents of the library/source set.
lib_sources = get_target_outputs(":$schema_generator_name")
lib_public_deps = [ ":$schema_generator_name" ]
lib_deps = [
"//base",
"//tools/json_schema_compiler:generated_api_util",
]
lib_extra_configs = []
if (defined(invoker.configs)) {
lib_extra_configs += invoker.configs
}
if (defined(invoker.deps)) {
lib_deps += invoker.deps
}
static_library(target_name) {
sources = lib_sources
deps = lib_deps
public_deps = lib_public_deps
configs += lib_extra_configs
configs += [ "//build/config/compiler:wexit_time_destructors" ]
public_configs = [ ":$generated_config_name" ]
if (defined(invoker.visibility)) {
visibility = invoker.visibility
}
}
}
Codebase Browser
chromium