| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2013 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 #include "tools/gn/functions.h" | |
| 6 | |
| 7 #include "tools/gn/err.h" | |
| 8 #include "tools/gn/parse_tree.h" | |
| 9 #include "tools/gn/scope.h" | |
| 10 #include "tools/gn/target_generator.h" | |
| 11 #include "tools/gn/value.h" | |
| 12 | |
| 13 namespace { | |
| 14 | |
| 15 Value ExecuteGenericTarget(const char* target_type, | |
| 16 Scope* scope, | |
| 17 const FunctionCallNode* function, | |
| 18 const std::vector<Value>& args, | |
| 19 BlockNode* block, | |
| 20 Err* err) { | |
| 21 if (!EnsureNotProcessingImport(function, scope, err) || | |
| 22 !EnsureNotProcessingBuildConfig(function, scope, err)) | |
| 23 return Value(); | |
| 24 Scope block_scope(scope); | |
| 25 if (!FillTargetBlockScope(scope, function, target_type, block, | |
| 26 args, &block_scope, err)) | |
| 27 return Value(); | |
| 28 | |
| 29 block->ExecuteBlockInScope(&block_scope, err); | |
| 30 if (err->has_error()) | |
| 31 return Value(); | |
| 32 | |
| 33 TargetGenerator::GenerateTarget(&block_scope, function->function(), args, | |
| 34 target_type, err); | |
| 35 | |
| 36 block_scope.CheckForUnusedVars(err); | |
| 37 return Value(); | |
| 38 } | |
| 39 | |
| 40 } // namespace | |
| 41 | |
| 42 Value ExecuteComponent(Scope* scope, | |
| 43 const FunctionCallNode* function, | |
| 44 const std::vector<Value>& args, | |
| 45 BlockNode* block, | |
| 46 Err* err) { | |
| 47 // A component is either a shared or static library, depending on the value | |
| 48 // of |component_mode|. | |
| 49 const Value* component_mode_value = scope->GetValue("component_mode"); | |
| 50 | |
| 51 static const char helptext[] = | |
| 52 "You're declaring a component here but have not defined " | |
| 53 "\"component_mode\" to\neither \"shared_library\" or \"static_library\"."; | |
| 54 if (!component_mode_value) { | |
| 55 *err = Err(function->function(), "No component mode set.", helptext); | |
| 56 return Value(); | |
| 57 } | |
| 58 if (component_mode_value->type() != Value::STRING || | |
| 59 (component_mode_value->string_value() != functions::kSharedLibrary && | |
| 60 component_mode_value->string_value() != functions::kStaticLibrary)) { | |
| 61 *err = Err(function->function(), "Invalid component mode set.", helptext); | |
| 62 return Value(); | |
| 63 } | |
| 64 const std::string& component_mode = component_mode_value->string_value(); | |
| 65 | |
| 66 if (!EnsureNotProcessingImport(function, scope, err)) | |
| 67 return Value(); | |
| 68 Scope block_scope(scope); | |
| 69 if (!FillTargetBlockScope(scope, function, component_mode.c_str(), block, | |
| 70 args, &block_scope, err)) | |
| 71 return Value(); | |
| 72 | |
| 73 block->ExecuteBlockInScope(&block_scope, err); | |
| 74 if (err->has_error()) | |
| 75 return Value(); | |
| 76 | |
| 77 TargetGenerator::GenerateTarget(&block_scope, function->function(), args, | |
| 78 component_mode, err); | |
| 79 return Value(); | |
| 80 } | |
| 81 | |
| 82 Value ExecuteCopy(Scope* scope, | |
| 83 const FunctionCallNode* function, | |
| 84 const std::vector<Value>& args, | |
| 85 Err* err) { | |
| 86 if (!EnsureNotProcessingImport(function, scope, err) || | |
| 87 !EnsureNotProcessingBuildConfig(function, scope, err)) | |
| 88 return Value(); | |
| 89 TargetGenerator::GenerateTarget(scope, function->function(), args, | |
| 90 functions::kCopy, err); | |
| 91 return Value(); | |
| 92 } | |
| 93 | |
| 94 /* | |
| 95 custom: Declare a script-generated target. | |
| 96 | |
| 97 This target type allows you to run a script over a set of sources files and | |
| 98 generate a set of output files. | |
| 99 | |
| 100 The script will be executed with the given arguments with the current | |
| 101 directory being that of the current BUILD file. | |
| 102 | |
| 103 There are two modes. The first mode is the "per-file" mode where you | |
| 104 specify a list of sources and the script is run once for each one as a build | |
| 105 rule. In this case, each file specified in the |outputs| variable must be | |
| 106 unique when applied to each source file (normally you would reference | |
| 107 "{{source_name_part}}" from within each one) or the build system will get | |
| 108 confused about how to build those files. You should use the |data| variable | |
| 109 to list all additional dependencies of your script: these will be added | |
| 110 as dependencies for each build step. | |
| 111 | |
| 112 The second mode is when you just want to run a script once rather than as a | |
| 113 general rule over a set of files. In this case you don't list any sources. | |
| 114 Dependencies of your script are specified only in the |data| variable and | |
| 115 your |outputs| variable should just list all outputs. | |
| 116 | |
| 117 Variables: | |
| 118 | |
| 119 args, data, deps, outputs, script*, sources | |
| 120 * = required | |
| 121 | |
| 122 There are some special substrings that will be searched for when processing | |
| 123 some variables: | |
| 124 | |
| 125 "{{source}}" | |
| 126 Expanded in |args|, this is the name of the source file relative to the | |
| 127 current directory when running the script. This is how you specify | |
| 128 the current input file to your script. | |
| 129 | |
| 130 "{{source_name_part}}" | |
| 131 Expanded in |args| and |outputs|, this is just the filename part of the | |
| 132 current source file with no directory or extension. This is how you | |
| 133 specify a name transoformation to the output. Normally you would | |
| 134 write an output as "$target_output_dir/{{source_name_part}}.o". | |
| 135 | |
| 136 All |outputs| files must be inside the output directory of the build. You | |
| 137 would generally use "$target_output_dir" or "$target_gen_dir" to reference | |
| 138 the output or generated intermediate file directories, respectively. | |
| 139 | |
| 140 Examples: | |
| 141 | |
| 142 custom("general_rule") { | |
| 143 script = "do_processing.py" | |
| 144 sources = [ "foo.idl" ] | |
| 145 data = [ "my_configuration.txt" ] | |
| 146 outputs = [ "$target_gen_dir/{{source_name_part}}.h" ] | |
| 147 args = [ "{{source}}", | |
| 148 "-o", "$relative_target_gen_dir/{{source_name_part}}.h" ] | |
| 149 } | |
| 150 | |
| 151 custom("just_run_this_guy_once") { | |
| 152 script = "doprocessing.py" | |
| 153 data = [ "my_configuration.txt" ] | |
| 154 outputs = [ "$target_gen_dir/insightful_output.txt" ] | |
| 155 args = [ "--output_dir", $target_gen_dir ] | |
| 156 } | |
| 157 */ | |
| 158 Value ExecuteCustom(Scope* scope, | |
| 159 const FunctionCallNode* function, | |
| 160 const std::vector<Value>& args, | |
| 161 BlockNode* block, | |
| 162 Err* err) { | |
| 163 return ExecuteGenericTarget(functions::kCustom, scope, function, args, | |
| 164 block, err); | |
| 165 } | |
| 166 | |
| 167 Value ExecuteExecutable(Scope* scope, | |
| 168 const FunctionCallNode* function, | |
| 169 const std::vector<Value>& args, | |
| 170 BlockNode* block, | |
| 171 Err* err) { | |
| 172 return ExecuteGenericTarget(functions::kExecutable, scope, function, args, | |
| 173 block, err); | |
| 174 } | |
| 175 | |
| 176 Value ExecuteSharedLibrary(Scope* scope, | |
| 177 const FunctionCallNode* function, | |
| 178 const std::vector<Value>& args, | |
| 179 BlockNode* block, | |
| 180 Err* err) { | |
| 181 return ExecuteGenericTarget(functions::kSharedLibrary, scope, function, args, | |
| 182 block, err); | |
| 183 } | |
| 184 | |
| 185 Value ExecuteStaticLibrary(Scope* scope, | |
| 186 const FunctionCallNode* function, | |
| 187 const std::vector<Value>& args, | |
| 188 BlockNode* block, | |
| 189 Err* err) { | |
| 190 return ExecuteGenericTarget(functions::kStaticLibrary, scope, function, args, | |
| 191 block, err); | |
| 192 } | |
| 193 | |
| 194 /* | |
| 195 group: Declare a group of targets. | |
| 196 | |
| 197 This target type allows you to create meta-targets that just collect a set | |
| 198 of dependencies into one named target. | |
| 199 | |
| 200 Variables: | |
| 201 | |
| 202 deps | |
| 203 | |
| 204 Example: | |
| 205 | |
| 206 group("all") { | |
| 207 deps = [ | |
| 208 "//project:runner", | |
| 209 "//project:unit_tests", | |
| 210 ] | |
| 211 } | |
| 212 */ | |
| 213 Value ExecuteGroup(Scope* scope, | |
| 214 const FunctionCallNode* function, | |
| 215 const std::vector<Value>& args, | |
| 216 BlockNode* block, | |
| 217 Err* err) { | |
| 218 return ExecuteGenericTarget(functions::kGroup, scope, function, args, | |
| 219 block, err); | |
| 220 } | |
| 221 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 21084010:
Revert 214254 "Add initial prototype for the GN meta-buildsystem." (Closed)
Base URL: svn://svn.chromium.org/chrome/