tools/gn/label.cc

   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() <= 2) {
  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(const SourceDir& dir, const base::StringPiece& name)
 204     : dir_(dir) {
 205   name_.assign(name.data(), name.size());
 206 }
 207
 208 Label::~Label() {
 209 }
 210
 211 // static
 212 Label Label::Resolve(const SourceDir& current_dir,
 213                      const Label& current_toolchain,
 214                      const Value& input,
 215                      Err* err) {
 216   Label ret;
 217   if (input.type() != Value::STRING) {
 218     *err = Err(input, "Dependency is not a string.");
 219     return ret;
 220   }
 221   const std::string& input_string = input.string_value();
 222   if (input_string.empty()) {
 223     *err = Err(input, "Dependency string is empty.");
 224     return ret;
 225   }
 226
 227   if (!::Resolve(current_dir, current_toolchain, input, input_string,
 228                  &ret.dir_, &ret.name_,
 229                  &ret.toolchain_dir_, &ret.toolchain_name_,
 230                  err))
 231     return Label();
 232   return ret;
 233 }
 234
 235 Label Label::GetToolchainLabel() const {
 236   return Label(toolchain_dir_, toolchain_name_);
 237 }
 238
 239 Label Label::GetWithNoToolchain() const {
 240   return Label(dir_, name_);
 241 }
 242
 243 std::string Label::GetUserVisibleName(bool include_toolchain) const {
 244   std::string ret;
 245   ret.reserve(dir_.value().size() + name_.size() + 1);
 246
 247   if (dir_.is_null())
 248     return ret;
 249
 250   ret = DirWithNoTrailingSlash(dir_);
 251   ret.push_back(':');
 252   ret.append(name_);
 253
 254   if (include_toolchain) {
 255     ret.push_back('(');
 256     if (!toolchain_dir_.is_null() && !toolchain_name_.empty()) {
 257       ret.append(DirWithNoTrailingSlash(toolchain_dir_));
 258       ret.push_back(':');
 259       ret.append(toolchain_name_);
 260     }
 261     ret.push_back(')');
 262   }
 263   return ret;
 264 }
 265
 266 std::string Label::GetUserVisibleName(const Label& default_toolchain) const {
 267   bool include_toolchain =
 268       default_toolchain.dir() != toolchain_dir_ ||
 269       default_toolchain.name() != toolchain_name_;
 270   return GetUserVisibleName(include_toolchain);
 271 }