| 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 |
|---|
Chromium Code Reviews
Issue 2350583002:
Starting work on full GN build (Closed)
