GN: Change gen command syntax, support relative dirs.

tools/gn/filesystem_utils.cc

 // 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/filesystem_utils.h"
 
 #include <algorithm>
 
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "tools/gn/location.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/source_dir.h"
 
 namespace {
 
@@ skipping 83 matching lines @@
   if (!((path[0] >= 'A' && path[0] <= 'Z') ||
          path[0] >= 'a' && path[0] <= 'z'))
     return false;
 
   if (path[2] != '/' && path[2] != '\\')
     return false;
   return true;
 }
 #endif
 
+// A wrapper around FilePath.GetComponents that works the way we need. This is
+// not super efficient since it does some O9n) transformations on the path. If

[Dirk Pranke, 2014/02/18 19:22:35]

typo: O9n) -> O(n)

+// this is called a lot, we might want to optimize.
+std::vector<base::FilePath::StringType> GetPathComponents(
+    const base::FilePath& path) {
+  std::vector<base::FilePath::StringType> result;
+  path.GetComponents(&result);
+
+  if (result.empty())
+    return result;
+
+  // GetComponents will preserve the "/" at the beginning, which confuses us.
+  // We don't expect to have relative paths in this function.
+  // Don't use IsSeparator since we always want to allow backslashes.
+  if (result[0] == FILE_PATH_LITERAL("/") ||
+      result[0] == FILE_PATH_LITERAL("\\"))
+    result.erase(result.begin());
+
+#if defined(OS_WIN)
+  // On Windows, GetComponents will give us [ "C:", "/", "foo" ], and we
+  // don't want the slash in there. This doesn't support input like "C:foo"
+  // which means foo relative to the current directory of the C drive but
+  // that's basically legacy DOS behavior we don't need to support.
+  if (result.size() >= 2 && result[1] == L"/" || result[1] == L"\\")
+    result.erase(result.begin() + 1);
+#endif
+
+  return result;
+}
+
+// Provides the equivalent of == for filesystem strings, trying to do
+// approximately the right thing with case.
+bool FilesystemStringsEqual(const base::FilePath::StringType& a,
+                            const base::FilePath::StringType& b) {
+#if defined(OS_WIN)
+  // Assume case-insesitive filesystems on Windows. We use the CompareString

[Dirk Pranke, 2014/02/18 19:22:35]

typo: case-insesitive -> case-insensitive.

+  // function to do a case-insensitive comparison based on the current locale
+  // (we don't want GN to depend on ICU which is large and requires data
+  // files). This isn't perfect, but getting this perfectly right is very
+  // difficult and requires I/O, and this comparison should cover 99.9999% of
+  // all cases.
+  //
+  // Note: The documentation for CompareString says it runs fastest on
+  // null-terminated strings with -1 passed for the length, so we do that here.
+  // There should not be embedded nulls in filesystem strings.
+  return ::CompareString(LOCALE_USER_DEFAULT, LINGUISTIC_IGNORECASE,
+                         a.c_str(), -1, b.c_str(), -1) == CSTR_EQUAL;
+#else
+  // Assume case-sensitive filesystems on non-Windows.
+  return a == b;

[Dirk Pranke, 2014/02/18 19:22:35]

isn't Mac also case-insensitive by default? (though I'm not sure it matters much
since everyone usually treats it as case-sensitive).

[brettw, 2014/02/18 20:22:46]

Hey, I didn't even know that. Let's see if we can get away with the current
case-sensitive behavior since the code I had to write on Windows is grody.

+#endif
+}
+
 }  // namespace
 
 SourceFileType GetSourceFileType(const SourceFile& file,
                                  Settings::TargetOS os) {
   base::StringPiece extension = FindExtension(&file.value());
   if (extension == "cc" || extension == "cpp" || extension == "cxx")
     return SOURCE_CC;
   if (extension == "h")
     return SOURCE_H;
   if (extension == "c")
@@ skipping 435 matching lines @@
     ret.assign("/.");
   } else if (dir.value() == "//") {
     ret.assign("//.");
   } else {
     ret.assign(dir.value());
     ret.resize(ret.size() - 1);
   }
   return ret;
 }
 
+SourceDir SourceDirForPath(const base::FilePath& source_root,
+                           const base::FilePath& path) {
+  std::vector<base::FilePath::StringType> source_comp =
+      GetPathComponents(source_root);
+  std::vector<base::FilePath::StringType> path_comp =
+      GetPathComponents(path);
+
+  // See if path is inside the source root by looking for each of source root's
+  // components at the beginning of path.
+  bool is_inside_source;
+  if (path_comp.size() < source_comp.size()) {
+    // Too small to fit.
+    is_inside_source = false;
+  } else {
+    is_inside_source = true;
+    for (size_t i = 0; i < source_comp.size(); i++) {
+      if (!FilesystemStringsEqual(source_comp[i], path_comp[i])) {
+        is_inside_source = false;
+        break;
+      }
+    }
+  }
+
+  std::string result_str;
+  size_t initial_path_comp_to_use;
+  if (is_inside_source) {
+    // Construct a source-relative path beginning in // and skip all of the
+    // shared directories.
+    result_str = "//";
+    initial_path_comp_to_use = source_comp.size();
+  } else {
+    // Not inside source code, construct a system-absolute path.
+    result_str = "/";
+    initial_path_comp_to_use = 0;
+  }
+
+  for (size_t i = initial_path_comp_to_use; i < path_comp.size(); i++) {
+    result_str.append(FilePathToUTF8(path_comp[i]));
+    result_str.push_back('/');
+  }
+  return SourceDir(result_str);
+}
+
+SourceDir SourceDirForCurrentDirectory(const base::FilePath& source_root) {
+  base::FilePath cd;
+  file_util::GetCurrentDirectory(&cd);
+  return SourceDirForPath(source_root, cd);
+}
+
 SourceDir GetToolchainOutputDir(const Settings* settings) {
   const OutputFile& toolchain_subdir = settings->toolchain_output_subdir();
 
   std::string result = settings->build_settings()->build_dir().value();
   if (!toolchain_subdir.value().empty())
     result.append(toolchain_subdir.value());
 
   return SourceDir(SourceDir::SWAP_IN, &result);
 }
 
@@ skipping 47 matching lines @@
   return GetGenDirForSourceDir(target->settings(), target->label().dir());
 }
 
 SourceDir GetCurrentOutputDir(const Scope* scope) {
   return GetOutputDirForSourceDir(scope->settings(), scope->GetSourceDir());
 }
 
 SourceDir GetCurrentGenDir(const Scope* scope) {
   return GetGenDirForSourceDir(scope->settings(), scope->GetSourceDir());
 }