GN: Use build directory for CD for scripts

tools/gn/function_to_build_path.cc

Index: tools/gn/function_to_build_path.cc
diff --git a/tools/gn/function_to_build_path.cc b/tools/gn/function_to_build_path.cc
new file mode 100644
index 0000000000000000000000000000000000000000..362f8c9322e2099a531fa224cf4b5edf14a31871
--- /dev/null
+++ b/tools/gn/function_to_build_path.cc
@@ -0,0 +1,140 @@
+// 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/build_settings.h"
+#include "tools/gn/functions.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/path_output.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/settings.h"
+#include "tools/gn/source_dir.h"
+#include "tools/gn/source_file.h"
+#include "tools/gn/value.h"
+
+namespace functions {
+
+namespace {
+
+// Returns true if the given value looks like a directory, otherwise we'll
+// assume it's a file.
+bool ValueLooksLikeDir(const std::string& value) {
+  if (value.empty())
+    return true;
+  size_t value_size = value.size();
+
+  // Count the number of dots at the end of the string.
+  size_t num_dots = 0;
+  while (num_dots < value_size && value[value_size - num_dots - 1] == '.')
+    num_dots++;
+
+  if (num_dots == value.size())
+    return true;  // String is all dots.
+
+  if (value[value_size - num_dots - 1] == '/' ||
+      value[value_size - num_dots - 1] == '\\')
+    return true;  // String is a [back]slash followed by 0 or more dots.
+
+  // Anything else.
+  return false;
+}
+
+Value ConvertOneBuildPath(const Scope* scope,
+                          const FunctionCallNode* function,
+                          const Value& value,
+                          const PathOutput& path_output,
+                          Err* err) {
+  if (!value.VerifyTypeIs(Value::STRING, err))
+    return Value();
+
+  const std::string& string_value = value.string_value();
+
+  std::ostringstream buffer;
+  if (ValueLooksLikeDir(string_value)) {
+    SourceDir absolute =
+        scope->GetSourceDir().ResolveRelativeDir(string_value);
+    path_output.WriteDir(buffer, absolute, PathOutput::DIR_NO_LAST_SLASH);
+  } else {
+    SourceFile absolute =
+        scope->GetSourceDir().ResolveRelativeFile(string_value);
+    path_output.WriteFile(buffer, absolute);
+  }
+  return Value(function, buffer.str());
+}
+
+}  // namespace
+
+const char kToBuildPath[] = "to_build_path";

[scottmg, 2013/09/14 04:53:16]

is this name from google3? i find it a bit confusing, mostly because of the
build dir vs. BUILD files i guess. 'relative_to_output' or something, not sure.

[brettw, 2013/09/16 17:59:02]

This is my own name. I agree the overlap of "build" is confusing and I'm open to
new names. I did "build" to not collide with the "out" dirs (like the
"root_out_dir" that I'm adding in this patch) which is the toolchain output
root, which is not necessarily the same as the root build directory. I could
call it "to_build_output_dir" but that seems unfortunately long.

I didn't really want to put "relative" in the name since this takes any file
name, often source-absolute ones like "//foo/bar.txt" or even system-absolute
ones like "/usr/include/foo.txt"

+const char kToBuildPath_Help[] =
+    "to_build_path: Rebase a file or directory to the build output dir.\n"
+    "\n"
+    "  <converted> = to_build_path(<file_or_path_string_or_list>)\n"
+    "\n"
+    "  Takes a string argument representing a file name, or a list of such\n"
+    "  strings and converts it/them to be relative to the root build output\n"
+    "  directory (which is the current directory when running scripts).\n"
+    "\n"
+    "  The input can be:\n"
+    "   - Paths relative to the BUILD file like \"foo.txt\".\n"
+    "   - Source-root absolute paths like \"//foo/bar/foo.txt\".\n"
+    "   - System absolute paths like \"/usr/include/foo.h\" or\n"
+    "     \"/C:/foo/bar.h\" (these will be passed unchanged).\n"
+    "   - A list of such values (the result will be a list of each item\n"
+    "     converted as per the above description).\n"
+    "\n"
+    "  Normally for sources and in cases where GN is providing file names\n"
+    "  to a tool, the paths will automatically be converted to be relative\n"
+    "  to the build directory. However, if you pass additional arguments,\n"
+    "  GN won't know that the string is actually a file path. These will\n"
+    "  need to be manually converted to be relative to the build dir using\n"
+    "  to_build_path().\n"
+    "\n"
+    "  Trailing slashes will not be reflected in the output.\n"
+    "\n"
+    "  Additionally, on Windows, slashes will be converted to backslashes.\n"
+    "\n"
+    "Example:\n"
+    "  custom(\"myscript\") {\n"
+    "    # Don't use for sources, GN will automatically convert these since\n"
+    "    # it knows they're files.\n"
+    "    sources = [ \"foo.txt\", \"bar.txt\" ]\n"

[scottmg, 2013/09/14 04:53:16]

this ended up very confusing in gyp, and there's some ugly heuristics to decide
when to pathify lists of strings (include dirs, sources, bla), but some things
are "sort of" pathy like libraries. i don't have a suggestion, but worth
thinking about i guess.

[brettw, 2013/09/16 17:59:02]

I think it's pretty clear here. Some things like sources and data are lists of
files. Args you pass manually are opaque and you have to manually convert them.

+    "\n"
+    "    # Extra file args passed manually need to be explicitly converted:\n"
+    "    args = [ \"--data\", to_build_path(\"//mything/data/input.dat\"),\n"
+    "             \"--rel\", to_build_path(\"relative_path.txt\") ]\n"
+    "  }\n";
+
+Value RunToBuildPath(Scope* scope,
+                     const FunctionCallNode* function,
+                     const std::vector<Value>& args,
+                     Err* err) {
+  if (args.size() != 1) {
+    *err = Err(function->function(), "to_build_path takes one argument.");
+    return Value();
+  }
+
+  const Value& value = args[0];
+  PathOutput path_output(scope->settings()->build_settings()->build_dir(),
+                         ESCAPE_NONE, true);
+
+  if (value.type() == Value::STRING) {
+    return ConvertOneBuildPath(scope, function, value, path_output, err);
+
+  } else if (value.type() == Value::LIST) {
+    Value ret(function, Value::LIST);
+    ret.list_value().reserve(value.list_value().size());
+
+    for (size_t i = 0; i < value.list_value().size(); i++) {
+      ret.list_value().push_back(
+          ConvertOneBuildPath(scope, function, value.list_value()[i],
+                              path_output, err));
+    }
+    return ret;
+  }
+
+  *err = Err(function->function(),
+             "to_build_path requires a list or a string.");
+  return Value();
+}
+
+}  // namespace functions