1 # Copyright 2014 The Chromium Authors. All rights reserved. 2 # Use of this source code is governed by a BSD-style license that can be 3 # found in the LICENSE file. 4 5 # Defines a static library corresponding to the output of schema compiler tools 6 # over a set of extensions API schemas (IDL or JSON format.) The library target 7 # has implicit hard dependencies on all schema files listed by the invoker and 8 # is itself a hard dependency. 9 # 10 # Invocations of this template may use the following variables: 11 # 12 # sources [required] A list of schema files to be compiled. 13 # 14 # root_namespace [required] 15 # A Python string substituion pattern used to generate the C++ 16 # namespace for each API. Use %(namespace)s to replace with the API 17 # namespace, like "toplevel::%(namespace)s_api". 18 # 19 # schema_include_rules [optional] 20 # A list of paths to include when searching for referenced objects, 21 # with the namespace separated by a :. 22 # Example: 23 # [ '/foo/bar:Foo::Bar::%(namespace)s' ] 24 # 25 # schemas [optional, default = false] 26 # Boolean indicating if the schema files should be generated. 27 # 28 # bundle [optional, default = false] 29 # Boolean indicating if the schema bundle files should be generated. 30 # 31 # bundle_registration [optional, default = false] 32 # Boolean indicating if the API registration bundle files should be generated. 33 # 34 # bundle_name [required if bundle or bundle_registrations]: 35 # A string to prepend to generated bundle class names, so that multiple 36 # bundle rules can be used without conflicting. Only used with one of 37 # the cpp-bundle generators. 38 # 39 # impl_dir [required if bundle_registration = true, otherwise unused] 40 # The path containing C++ implementations of API functions. This path is 41 # used as the root path when looking for {schema}/{schema}_api.h headers 42 # when generating API registration bundles. Such headers, if found, are 43 # automatically included by the generated code. 44 # 45 # uncompiled_sources [optional, only used when bundle = true or 46 # bundle_registration = true] 47 # A list of schema files which should not be compiled, but which should still 48 # be processed for API bundle generation. 49 # 50 # configs [optional] 51 # Extra configs to apply to the compile step. 52 # 53 # deps [optional] 54 # If any deps are specified they will be inherited by the static library 55 # target. 56 # 57 # generate_static_library [optional, defaults to false] 58 # Produces a static library instead of a source_set. 59 # 60 # The generated library target also inherits the visibility and output_name 61 # of its invoker. 62 63 template("json_schema_api") { 64 assert(defined(invoker.sources), 65 "\"sources\" must be defined for the $target_name template.") 66 assert(defined(invoker.root_namespace), 67 "\"root_namespace\" must be defined for the $target_name template.") 68 69 schemas = defined(invoker.schemas) && invoker.schemas 70 bundle = defined(invoker.bundle) && invoker.bundle 71 bundle_registration = 72 defined(invoker.bundle_registration) && invoker.bundle_registration 73 74 schema_include_rules = "" 75 if (defined(invoker.schema_include_rules)) { 76 schema_include_rules = invoker.schema_include_rules 77 } 78 79 # Keep a copy of the target_name here since it will be trampled 80 # in nested targets. 81 target_visibility = [ ":$target_name" ] 82 83 generated_config_name = target_name + "_generated_config" 84 config(generated_config_name) { 85 include_dirs = [ root_gen_dir ] 86 visibility = target_visibility 87 } 88 89 root_namespace = invoker.root_namespace 90 91 compiler_root = "//tools/json_schema_compiler" 92 compiler_script = "$compiler_root/compiler.py" 93 compiler_sources = [ 94 "$compiler_root/cc_generator.py", 95 "$compiler_root/code.py", 96 "$compiler_root/compiler.py", 97 "$compiler_root/cpp_bundle_generator.py", 98 "$compiler_root/cpp_generator.py", 99 "$compiler_root/cpp_type_generator.py", 100 "$compiler_root/cpp_util.py", 101 "$compiler_root/h_generator.py", 102 "$compiler_root/idl_schema.py", 103 "$compiler_root/model.py", 104 "$compiler_root/util_cc_helper.py", 105 ] 106 107 if (schemas) { 108 schema_generator_name = target_name + "_schema_generator" 109 action_foreach(schema_generator_name) { 110 script = compiler_script 111 sources = invoker.sources 112 inputs = compiler_sources 113 outputs = [ 114 "$target_gen_dir/{{source_name_part}}.cc", 115 "$target_gen_dir/{{source_name_part}}.h", 116 ] 117 args = [ 118 "{{source}}", 119 "--root=" + rebase_path("//", root_build_dir), 120 "--destdir=" + rebase_path(root_gen_dir, root_build_dir), 121 "--namespace=$root_namespace", 122 "--generator=cpp", 123 "--include-rules=$schema_include_rules", 124 ] 125 126 if (defined(invoker.visibility)) { 127 # If visibility is restricted, add our own target to it. 128 visibility = invoker.visibility + target_visibility 129 } 130 } 131 } 132 133 if (bundle) { 134 assert(defined(invoker.bundle_name), 135 "\"bundle_name\" must be defined for bundles") 136 137 uncompiled_sources = [] 138 if (defined(invoker.uncompiled_sources)) { 139 uncompiled_sources = invoker.uncompiled_sources 140 } 141 142 bundle_generator_schema_name = target_name + "_bundle_generator_schema" 143 action(bundle_generator_schema_name) { 144 script = compiler_script 145 inputs = compiler_sources + invoker.sources + uncompiled_sources 146 outputs = [ 147 "$target_gen_dir/generated_schemas.cc", 148 "$target_gen_dir/generated_schemas.h", 149 ] 150 args = [ 151 "--root=" + rebase_path("//", root_build_dir), 152 "--destdir=" + rebase_path(root_gen_dir, root_build_dir), 153 "--namespace=$root_namespace", 154 "--bundle-name=" + invoker.bundle_name, 155 "--generator=cpp-bundle-schema", 156 "--include-rules=$schema_include_rules", 157 ] + rebase_path(invoker.sources, root_build_dir) + 158 rebase_path(uncompiled_sources, root_build_dir) 159 } 160 } 161 162 if (bundle_registration) { 163 assert(defined(invoker.bundle_name), 164 "\"bundle_name\" must be defined for bundle registrations") 165 166 uncompiled_sources = [] 167 if (defined(invoker.uncompiled_sources)) { 168 uncompiled_sources = invoker.uncompiled_sources 169 } 170 171 assert(defined(invoker.impl_dir), 172 "\"impl_dir\" must be defined for the $target_name template.") 173 174 # Child directory inside the generated file tree. 175 gen_child_dir = rebase_path(invoker.impl_dir, "//") 176 177 bundle_generator_registration_name = 178 target_name + "_bundle_generator_registration" 179 action(bundle_generator_registration_name) { 180 script = compiler_script 181 inputs = compiler_sources + invoker.sources + uncompiled_sources 182 outputs = [ 183 "$root_gen_dir/$gen_child_dir/generated_api_registration.cc", 184 "$root_gen_dir/$gen_child_dir/generated_api_registration.h", 185 ] 186 args = [ 187 "--root=" + rebase_path("//", root_build_dir), 188 "--destdir=" + rebase_path(root_gen_dir, root_build_dir), 189 "--namespace=$root_namespace", 190 "--bundle-name=" + invoker.bundle_name, 191 "--generator=cpp-bundle-registration", 192 "--impl-dir=$gen_child_dir", 193 "--include-rules=$schema_include_rules", 194 ] + rebase_path(invoker.sources, root_build_dir) + 195 rebase_path(uncompiled_sources, root_build_dir) 196 } 197 } 198 199 # Compute the contents of the library/source set. 200 lib_sources = invoker.sources 201 lib_deps = [] 202 lib_public_deps = [] 203 lib_extra_configs = [] 204 if (defined(invoker.configs)) { 205 lib_extra_configs += invoker.configs 206 } 207 208 if (schemas) { 209 lib_sources += get_target_outputs(":$schema_generator_name") 210 lib_public_deps += [ ":$schema_generator_name" ] 211 lib_deps += [ "//tools/json_schema_compiler:generated_api_util" ] 212 lib_extra_configs += [ "//build/config/compiler:no_size_t_to_int_warning" ] 213 } 214 215 if (bundle) { 216 lib_sources += get_target_outputs(":$bundle_generator_schema_name") 217 lib_deps += [ ":$bundle_generator_schema_name" ] 218 } 219 220 if (bundle_registration) { 221 lib_sources += get_target_outputs(":$bundle_generator_registration_name") 222 lib_deps += [ ":$bundle_generator_registration_name" ] 223 } 224 225 if (defined(invoker.deps)) { 226 lib_deps += invoker.deps 227 } 228 229 # Generate either a static library or a source set. 230 if (defined(invoker.generate_static_library) && 231 invoker.generate_static_library) { 232 static_library(target_name) { 233 sources = lib_sources 234 deps = lib_deps 235 public_deps = lib_public_deps 236 configs += lib_extra_configs 237 public_configs = [ ":$generated_config_name" ] 238 239 if (defined(invoker.visibility)) { 240 visibility = invoker.visibility 241 } 242 if (defined(invoker.output_name)) { 243 output_name = invoker.output_name 244 } 245 } 246 } else { 247 source_set(target_name) { 248 sources = lib_sources 249 deps = lib_deps 250 public_deps = lib_public_deps 251 configs += lib_extra_configs 252 public_configs = [ ":$generated_config_name" ] 253 254 if (defined(invoker.visibility)) { 255 visibility = invoker.visibility 256 } 257 if (defined(invoker.output_name)) { 258 output_name = invoker.output_name 259 } 260 } 261 } 262 } 263
