OLD | NEW |
(Empty) | |
| 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 # impl_dir [required if bundle_registration = true, otherwise unused] |
| 35 # The path containing C++ implementations of API functions. This path is |
| 36 # used as the root path when looking for {schema}/{schema}_api.h headers |
| 37 # when generating API registration bundles. Such headers, if found, are |
| 38 # automatically included by the generated code. |
| 39 # |
| 40 # uncompiled_sources [optional, only used when bundle = true or |
| 41 # bundle_registration = true] |
| 42 # A list of schema files which should not be compiled, but which should still |
| 43 # be processed for API bundle generation. |
| 44 # |
| 45 # deps [optional] |
| 46 # If any deps are specified they will be inherited by the static library |
| 47 # target. |
| 48 # |
| 49 # generate_static_library [optional, defaults to false] |
| 50 # Produces a static library instead of a source_set. |
| 51 # |
| 52 # The generated library target also inherits the visibility and output_name |
| 53 # of its invoker. |
| 54 |
| 55 template("json_schema_api") { |
| 56 assert(defined(invoker.sources), |
| 57 "\"sources\" must be defined for the $target_name template.") |
| 58 assert(defined(invoker.root_namespace), |
| 59 "\"root_namespace\" must be defined for the $target_name template.") |
| 60 |
| 61 schemas = defined(invoker.schemas) && invoker.schemas |
| 62 bundle = defined(invoker.bundle) && invoker.bundle |
| 63 bundle_registration = |
| 64 defined(invoker.bundle_registration) && invoker.bundle_registration |
| 65 |
| 66 schema_include_rules = "" |
| 67 if (defined(invoker.schema_include_rules)) { |
| 68 schema_include_rules = invoker.schema_include_rules |
| 69 } |
| 70 |
| 71 # Keep a copy of the target_name here since it will be trampled |
| 72 # in nested targets. |
| 73 target_visibility = [ ":$target_name" ] |
| 74 |
| 75 generated_config_name = target_name + "_generated_config" |
| 76 config(generated_config_name) { |
| 77 include_dirs = [ root_gen_dir ] |
| 78 visibility = target_visibility |
| 79 } |
| 80 |
| 81 root_namespace = invoker.root_namespace |
| 82 |
| 83 compiler_root = "//tools/json_schema_compiler" |
| 84 compiler_script = "$compiler_root/compiler.py" |
| 85 compiler_sources = [ |
| 86 "$compiler_root/cc_generator.py", |
| 87 "$compiler_root/code.py", |
| 88 "$compiler_root/compiler.py", |
| 89 "$compiler_root/cpp_generator.py", |
| 90 "$compiler_root/cpp_type_generator.py", |
| 91 "$compiler_root/cpp_util.py", |
| 92 "$compiler_root/h_generator.py", |
| 93 "$compiler_root/idl_schema.py", |
| 94 "$compiler_root/model.py", |
| 95 "$compiler_root/util_cc_helper.py", |
| 96 ] |
| 97 |
| 98 if (schemas) { |
| 99 schema_generator_name = target_name + "_schema_generator" |
| 100 action_foreach(schema_generator_name) { |
| 101 script = compiler_script |
| 102 sources = invoker.sources |
| 103 inputs = compiler_sources |
| 104 outputs = [ |
| 105 "$target_gen_dir/{{source_name_part}}.cc", |
| 106 "$target_gen_dir/{{source_name_part}}.h", |
| 107 ] |
| 108 args = [ |
| 109 "{{source}}", |
| 110 "--root=" + rebase_path("//", root_build_dir), |
| 111 "--destdir=" + rebase_path(root_gen_dir, root_build_dir), |
| 112 "--namespace=$root_namespace", |
| 113 "--generator=cpp", |
| 114 "--include-rules=$schema_include_rules", |
| 115 ] |
| 116 |
| 117 if (defined(invoker.visibility)) { |
| 118 # If visibility is restricted, add our own target to it. |
| 119 visibility = invoker.visibility + target_visibility |
| 120 } |
| 121 } |
| 122 } |
| 123 |
| 124 if (bundle) { |
| 125 uncompiled_sources = [] |
| 126 if (defined(invoker.uncompiled_sources)) { |
| 127 uncompiled_sources = invoker.uncompiled_sources |
| 128 } |
| 129 |
| 130 bundle_generator_schema_name = target_name + "_bundle_generator_schema" |
| 131 action(bundle_generator_schema_name) { |
| 132 script = compiler_script |
| 133 inputs = compiler_sources + invoker.sources + uncompiled_sources |
| 134 outputs = [ |
| 135 "$target_gen_dir/generated_schemas.cc", |
| 136 "$target_gen_dir/generated_schemas.h", |
| 137 ] |
| 138 args = [ |
| 139 "--root=" + rebase_path("//", root_build_dir), |
| 140 "--destdir=" + rebase_path(root_gen_dir, root_build_dir), |
| 141 "--namespace=$root_namespace", |
| 142 "--generator=cpp-bundle-schema", |
| 143 "--include-rules=$schema_include_rules", |
| 144 ] + rebase_path(invoker.sources, root_build_dir) + |
| 145 rebase_path(uncompiled_sources, root_build_dir) |
| 146 } |
| 147 } |
| 148 |
| 149 if (bundle_registration) { |
| 150 uncompiled_sources = [] |
| 151 if (defined(invoker.uncompiled_sources)) { |
| 152 uncompiled_sources = invoker.uncompiled_sources |
| 153 } |
| 154 |
| 155 assert(defined(invoker.impl_dir), |
| 156 "\"impl_dir\" must be defined for the $target_name template.") |
| 157 |
| 158 # Child directory inside the generated file tree. |
| 159 gen_child_dir = rebase_path(invoker.impl_dir, "//") |
| 160 |
| 161 bundle_generator_registration_name = |
| 162 target_name + "_bundle_generator_registration" |
| 163 action(bundle_generator_registration_name) { |
| 164 script = compiler_script |
| 165 inputs = compiler_sources + invoker.sources + uncompiled_sources |
| 166 outputs = [ |
| 167 "$root_gen_dir/$gen_child_dir/generated_api_registration.cc", |
| 168 "$root_gen_dir/$gen_child_dir/generated_api_registration.h", |
| 169 ] |
| 170 args = [ |
| 171 "--root=" + rebase_path("//", root_build_dir), |
| 172 "--destdir=" + rebase_path(root_gen_dir, root_build_dir), |
| 173 "--namespace=$root_namespace", |
| 174 "--generator=cpp-bundle-registration", |
| 175 "--impl-dir=$gen_child_dir", |
| 176 "--include-rules=$schema_include_rules", |
| 177 ] + rebase_path(invoker.sources, root_build_dir) + |
| 178 rebase_path(uncompiled_sources, root_build_dir) |
| 179 } |
| 180 } |
| 181 |
| 182 # Compute the contents of the library/source set. |
| 183 lib_sources = invoker.sources |
| 184 lib_deps = [] |
| 185 lib_public_deps = [] |
| 186 lib_extra_configs = [] |
| 187 |
| 188 if (schemas) { |
| 189 lib_sources += get_target_outputs(":$schema_generator_name") |
| 190 lib_public_deps += [ ":$schema_generator_name" ] |
| 191 lib_deps += [ "//tools/json_schema_compiler:generated_api_util" ] |
| 192 lib_extra_configs += [ "//build/config/compiler:no_size_t_to_int_warning" ] |
| 193 } |
| 194 |
| 195 if (bundle) { |
| 196 lib_sources += get_target_outputs(":$bundle_generator_schema_name") |
| 197 lib_deps += [ ":$bundle_generator_schema_name" ] |
| 198 } |
| 199 |
| 200 if (bundle_registration) { |
| 201 lib_sources += get_target_outputs(":$bundle_generator_registration_name") |
| 202 lib_deps += [ ":$bundle_generator_registration_name" ] |
| 203 } |
| 204 |
| 205 if (defined(invoker.deps)) { |
| 206 lib_deps += invoker.deps |
| 207 } |
| 208 |
| 209 # Generate either a static library or a source set. |
| 210 if (defined(invoker.generate_static_library) && |
| 211 invoker.generate_static_library) { |
| 212 static_library(target_name) { |
| 213 sources = lib_sources |
| 214 deps = lib_deps |
| 215 public_deps = lib_public_deps |
| 216 configs += lib_extra_configs |
| 217 public_configs = [ ":$generated_config_name" ] |
| 218 |
| 219 if (defined(invoker.visibility)) { |
| 220 visibility = invoker.visibility |
| 221 } |
| 222 if (defined(invoker.output_name)) { |
| 223 output_name = invoker.output_name |
| 224 } |
| 225 } |
| 226 } else { |
| 227 source_set(target_name) { |
| 228 sources = lib_sources |
| 229 deps = lib_deps |
| 230 public_deps = lib_public_deps |
| 231 configs += lib_extra_configs |
| 232 public_configs = [ ":$generated_config_name" ] |
| 233 |
| 234 if (defined(invoker.visibility)) { |
| 235 visibility = invoker.visibility |
| 236 } |
| 237 if (defined(invoker.output_name)) { |
| 238 output_name = invoker.output_name |
| 239 } |
| 240 } |
| 241 } |
| 242 } |
OLD | NEW |