GYP generator for GN

tools/gn/gyp_helper.cc

Index: tools/gn/gyp_helper.cc
diff --git a/tools/gn/gyp_helper.cc b/tools/gn/gyp_helper.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f69ed8f2097d29a2b0c22d9795694fe17007b4ae
--- /dev/null
+++ b/tools/gn/gyp_helper.cc
@@ -0,0 +1,105 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "tools/gn/gyp_helper.h"
+
+#include "tools/gn/err.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/settings.h"
+#include "tools/gn/source_file.h"
+#include "tools/gn/target.h"
+#include "tools/gn/toolchain.h"
+
+GypHelper::GypHelper() {
+}
+
+GypHelper::~GypHelper() {
+}
+
+SourceFile GypHelper::GetGypFileForTarget(const Target* target,
+                                          Err* err) const {
+  // Use the manually specified one if its there.
+  if (!target->gyp_file().is_null())
+    return target->gyp_file();
+
+  // Otherwise inherit the directory name.
+  const std::string& dir = target->label().dir().value();
+  size_t last_slash = dir.size() - 1;
+  std::string dir_name;
+  if (last_slash > 0) {
+    size_t next_to_last_slash = dir.rfind('/', last_slash - 1);
+    if (next_to_last_slash != std::string::npos) {
+      dir_name = dir.substr(next_to_last_slash + 1,
+                            last_slash - next_to_last_slash - 1);
+    }
+  }
+  if (dir_name.empty()) {
+    *err = Err(Location(), "Need to specify a gyp_file value for " +
+        target->label().GetUserVisibleName(false) + "\n"
+        "since I can't make up one with no name.");
+    return SourceFile();
+  }
+
+  return SourceFile(dir + dir_name + ".gyp");
+}
+
+std::string GypHelper::GetNameForTarget(const Target* target) const {
+  const Toolchain* toolchain = target->settings()->toolchain();
+  if (toolchain->is_default())
+    return target->label().name();  // Default toolchain has no suffix.
+  return target->label().name() + "_" + toolchain->label().name();
+}
+
+std::string GypHelper::GetFullRefForTarget(const Target* target) const {
+  Err err;
+  SourceFile gypfile = GetGypFileForTarget(target, &err);
+  CHECK(gypfile.is_source_absolute()) <<
+      "GYP files should not be system-absolute: " << gypfile.value();
+
+  std::string ret("<(DEPTH)/");
+  // Trim off the leading double-slash.
+  ret.append(&gypfile.value()[2], gypfile.value().size() - 2);
+  ret.push_back(':');
+  ret.append(GetNameForTarget(target));
+
+  return ret;
+}
+
+std::string GypHelper::GetFileReference(const SourceFile& file) const {
+  std::string ret;
+  if (file.is_null())
+    return ret;
+
+  // Use FilePath's resolver to get the system paths out (on Windows this
+  // requires special handling). Since it's absolute, it doesn't matter what
+  // we pass in as the source root.
+  if (file.is_system_absolute())
+    return FilePathToUTF8(file.Resolve(base::FilePath()));
+
+  // Source root relative, strip the "//".
+  ret.assign("<(DEPTH)/");
+  ret.append(&file.value()[2], file.value().size() - 2);
+  return ret;
+}
+
+std::string GypHelper::GetDirReference(const SourceDir& dir,
+                                       bool include_slash) const {
+  std::string ret;
+  if (dir.is_null())
+    return ret;
+
+  if (dir.is_system_absolute()) {
+    ret = FilePathToUTF8(dir.Resolve(base::FilePath()));
+  } else {
+    ret.assign("<(DEPTH)/");
+    ret.append(&dir.value()[2], dir.value().size() - 2);
+  }
+
+  // Optionally trim the slash off the end.
+  if (!ret.empty() && !include_slash &&
+      (ret[ret.size() - 1] == '/' || ret[ret.size() - 1] == '\\'))
+    ret.resize(ret.size() - 1);
+
+  return ret;
+}