| 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/label.h" | |
| 6 | |
| 7 #include "base/logging.h" | |
| 8 #include "tools/gn/err.h" | |
| 9 #include "tools/gn/parse_tree.h" | |
| 10 #include "tools/gn/value.h" | |
| 11 | |
| 12 namespace { | |
| 13 | |
| 14 // We print user visible label names with no trailing slash after the | |
| 15 // directory name. | |
| 16 std::string DirWithNoTrailingSlash(const SourceDir& dir) { | |
| 17 // Be careful not to trim if the input is just "/" or "//". | |
| 18 if (dir.value().size() > 2) | |
| 19 return dir.value().substr(0, dir.value().size() - 1); | |
| 20 return dir.value(); | |
| 21 } | |
| 22 | |
| 23 // Given the separate-out input (everything before the colon) in the dep rule, | |
| 24 // computes the final build rule. Sets err on failure. On success, | |
| 25 // |*used_implicit| will be set to whether the implicit current directory was | |
| 26 // used. The value is used only for generating error messages. | |
| 27 bool ComputeBuildLocationFromDep(const Value& input_value, | |
| 28 const SourceDir& current_dir, | |
| 29 const base::StringPiece& input, | |
| 30 SourceDir* result, | |
| 31 Err* err) { | |
| 32 // No rule, use the current locaton. | |
| 33 if (input.empty()) { | |
| 34 *result = current_dir; | |
| 35 return true; | |
| 36 } | |
| 37 | |
| 38 // Don't allow directories to start with a single slash. All labels must be | |
| 39 // in the source root. | |
| 40 if (input[0] == '/' && (input.size() == 1 || input[1] != '/')) { | |
| 41 *err = Err(input_value, "Label can't start with a single slash", | |
| 42 "Labels must be either relative (no slash at the beginning) or be " | |
| 43 "absolute\ninside the source root (two slashes at the beginning)."); | |
| 44 return false; | |
| 45 } | |
| 46 | |
| 47 *result = current_dir.ResolveRelativeDir(input); | |
| 48 return true; | |
| 49 } | |
| 50 | |
| 51 // Given the separated-out target name (after the colon) computes the final | |
| 52 // name, using the implicit name from the previously-generated | |
| 53 // computed_location if necessary. The input_value is used only for generating | |
| 54 // error messages. | |
| 55 bool ComputeTargetNameFromDep(const Value& input_value, | |
| 56 const SourceDir& computed_location, | |
| 57 const base::StringPiece& input, | |
| 58 std::string* result, | |
| 59 Err* err) { | |
| 60 if (!input.empty()) { | |
| 61 // Easy case: input is specified, just use it. | |
| 62 result->assign(input.data(), input.size()); | |
| 63 return true; | |
| 64 } | |
| 65 | |
| 66 const std::string& loc = computed_location.value(); | |
| 67 | |
| 68 // Use implicit name. The path will be "//", "//base/", "//base/i18n/", etc. | |
| 69 if (loc.size() <= 1) { | |
| 70 *err = Err(input_value, "This dependency name is empty"); | |
| 71 return false; | |
| 72 } | |
| 73 | |
| 74 size_t next_to_last_slash = loc.rfind('/', loc.size() - 2); | |
| 75 DCHECK(next_to_last_slash != std::string::npos); | |
| 76 result->assign(&loc[next_to_last_slash + 1], | |
| 77 loc.size() - next_to_last_slash - 2); | |
| 78 return true; | |
| 79 } | |
| 80 | |
| 81 // The original value is used only for error reporting, use the |input| as the | |
| 82 // input to this function (which may be a substring of the original value when | |
| 83 // we're parsing toolchains. | |
| 84 // | |
| 85 // If the output toolchain vars are NULL, then we'll report an error if we | |
| 86 // find a toolchain specified (this is used when recursively parsing toolchain | |
| 87 // labels which themselves can't have toolchain specs). | |
| 88 // | |
| 89 // We assume that the output variables are initialized to empty so we don't | |
| 90 // write them unless we need them to contain something. | |
| 91 // | |
| 92 // Returns true on success. On failure, the out* variables might be written to | |
| 93 // but shouldn't be used. | |
| 94 bool Resolve(const SourceDir& current_dir, | |
| 95 const Label& current_toolchain, | |
| 96 const Value& original_value, | |
| 97 const base::StringPiece& input, | |
| 98 SourceDir* out_dir, | |
| 99 std::string* out_name, | |
| 100 SourceDir* out_toolchain_dir, | |
| 101 std::string* out_toolchain_name, | |
| 102 Err* err) { | |
| 103 // To workaround the problem that StringPiece operator[] doesn't return a ref. | |
| 104 const char* input_str = input.data(); | |
| 105 | |
| 106 size_t path_separator = input.find_first_of(":("); | |
| 107 base::StringPiece location_piece; | |
| 108 base::StringPiece name_piece; | |
| 109 base::StringPiece toolchain_piece; | |
| 110 if (path_separator == std::string::npos) { | |
| 111 location_piece = input; | |
| 112 // Leave name & toolchain piece null. | |
| 113 } else { | |
| 114 location_piece = base::StringPiece(&input_str[0], path_separator); | |
| 115 | |
| 116 size_t toolchain_separator = input.find('(', path_separator); | |
| 117 if (toolchain_separator == std::string::npos) { | |
| 118 name_piece = base::StringPiece(&input_str[path_separator + 1], | |
| 119 input.size() - path_separator - 1); | |
| 120 // Leave location piece null. | |
| 121 } else if (!out_toolchain_dir) { | |
| 122 // Toolchain specified but not allows in this context. | |
| 123 *err = Err(original_value, "Toolchain has a toolchain.", | |
| 124 "Your toolchain definition (inside the parens) seems to itself " | |
| 125 "have a\ntoolchain. Don't do this."); | |
| 126 return false; | |
| 127 } else { | |
| 128 // Name piece is everything between the two separators. Note that the | |
| 129 // separators may be the same (e.g. "//foo(bar)" which means empty name. | |
| 130 if (toolchain_separator > path_separator) { | |
| 131 name_piece = base::StringPiece( | |
| 132 &input_str[path_separator + 1], | |
| 133 toolchain_separator - path_separator - 1); | |
| 134 } | |
| 135 | |
| 136 // Toolchain name should end in a ) and this should be the end of the | |
| 137 // string. | |
| 138 if (input[input.size() - 1] != ')') { | |
| 139 *err = Err(original_value, "Bad toolchain name.", | |
| 140 "Toolchain name must end in a \")\" at the end of the label."); | |
| 141 return false; | |
| 142 } | |
| 143 | |
| 144 // Subtract off the two parens to just get the toolchain name. | |
| 145 toolchain_piece = base::StringPiece( | |
| 146 &input_str[toolchain_separator + 1], | |
| 147 input.size() - toolchain_separator - 2); | |
| 148 } | |
| 149 } | |
| 150 | |
| 151 // Everything before the separator is the filename. | |
| 152 // We allow three cases: | |
| 153 // Absolute: "//foo:bar" -> /foo:bar | |
| 154 // Target in current file: ":foo" -> <currentdir>:foo | |
| 155 // Path with implicit name: "/foo" -> /foo:foo | |
| 156 if (location_piece.empty() && name_piece.empty()) { | |
| 157 // Can't use both implicit filename and name (":"). | |
| 158 *err = Err(original_value, "This doesn't specify a dependency."); | |
| 159 return false; | |
| 160 } | |
| 161 | |
| 162 if (!ComputeBuildLocationFromDep(original_value, current_dir, location_piece, | |
| 163 out_dir, err)) | |
| 164 return false; | |
| 165 | |
| 166 if (!ComputeTargetNameFromDep(original_value, *out_dir, name_piece, | |
| 167 out_name, err)) | |
| 168 return false; | |
| 169 | |
| 170 // Last, do the toolchains. | |
| 171 if (out_toolchain_dir) { | |
| 172 // Handle empty toolchain strings. We don't allow normal labels to be | |
| 173 // empty so we can't allow the recursive call of this function to do this | |
| 174 // check. | |
| 175 if (toolchain_piece.empty()) { | |
| 176 *out_toolchain_dir = current_toolchain.dir(); | |
| 177 *out_toolchain_name = current_toolchain.name(); | |
| 178 return true; | |
| 179 } else { | |
| 180 return Resolve(current_dir, current_toolchain, | |
| 181 original_value, toolchain_piece, | |
| 182 out_toolchain_dir, out_toolchain_name, NULL, NULL, err); | |
| 183 } | |
| 184 } | |
| 185 return true; | |
| 186 } | |
| 187 | |
| 188 } // namespace | |
| 189 | |
| 190 Label::Label() { | |
| 191 } | |
| 192 | |
| 193 Label::Label(const SourceDir& dir, | |
| 194 const base::StringPiece& name, | |
| 195 const SourceDir& toolchain_dir, | |
| 196 const base::StringPiece& toolchain_name) | |
| 197 : dir_(dir), | |
| 198 toolchain_dir_(toolchain_dir) { | |
| 199 name_.assign(name.data(), name.size()); | |
| 200 toolchain_name_.assign(toolchain_name.data(), toolchain_name.size()); | |
| 201 } | |
| 202 | |
| 203 Label::~Label() { | |
| 204 } | |
| 205 | |
| 206 // static | |
| 207 Label Label::Resolve(const SourceDir& current_dir, | |
| 208 const Label& current_toolchain, | |
| 209 const Value& input, | |
| 210 Err* err) { | |
| 211 Label ret; | |
| 212 if (input.type() != Value::STRING) { | |
| 213 *err = Err(input, "Dependency is not a string."); | |
| 214 return ret; | |
| 215 } | |
| 216 const std::string& input_string = input.string_value(); | |
| 217 if (input_string.empty()) { | |
| 218 *err = Err(input, "Dependency string is empty."); | |
| 219 return ret; | |
| 220 } | |
| 221 | |
| 222 if (!::Resolve(current_dir, current_toolchain, input, input_string, | |
| 223 &ret.dir_, &ret.name_, | |
| 224 &ret.toolchain_dir_, &ret.toolchain_name_, | |
| 225 err)) | |
| 226 return Label(); | |
| 227 return ret; | |
| 228 } | |
| 229 | |
| 230 Label Label::GetToolchainLabel() const { | |
| 231 return Label(toolchain_dir_, toolchain_name_, | |
| 232 SourceDir(), base::StringPiece()); | |
| 233 } | |
| 234 | |
| 235 std::string Label::GetUserVisibleName(bool include_toolchain) const { | |
| 236 std::string ret; | |
| 237 ret.reserve(dir_.value().size() + name_.size() + 1); | |
| 238 | |
| 239 if (dir_.is_null()) | |
| 240 return ret; | |
| 241 | |
| 242 ret = DirWithNoTrailingSlash(dir_); | |
| 243 ret.push_back(':'); | |
| 244 ret.append(name_); | |
| 245 | |
| 246 if (include_toolchain) { | |
| 247 ret.push_back('('); | |
| 248 if (!toolchain_dir_.is_null() && !toolchain_name_.empty()) { | |
| 249 ret.append(DirWithNoTrailingSlash(toolchain_dir_)); | |
| 250 ret.push_back(':'); | |
| 251 ret.append(toolchain_name_); | |
| 252 } | |
| 253 ret.push_back(')'); | |
| 254 } | |
| 255 return ret; | |
| 256 } | |
| 257 | |
| 258 std::string Label::GetUserVisibleName(const Label& default_toolchain) const { | |
| 259 bool include_toolchain = | |
| 260 default_toolchain.dir() != toolchain_dir_ || | |
| 261 default_toolchain.name() != toolchain_name_; | |
| 262 return GetUserVisibleName(include_toolchain); | |
| 263 } | |
| 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/