GN: Use build directory for CD for scripts

tools/gn/functions_target.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/functions.h"
 
 #include "tools/gn/config_values_generator.h"
 #include "tools/gn/err.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scope.h"
@@ skipping 105 matching lines @@
 // custom ----------------------------------------------------------------------
 
 const char kCustom[] = "custom";
 const char kCustom_Help[] =
     "custom: Declare a script-generated target.\n"
     "\n"
     "  This target type allows you to run a script over a set of source\n"
     "  files and generate a set of output files.\n"
     "\n"
     "  The script will be executed with the given arguments with the current\n"
-    "  directory being that of the current BUILD file.\n"
+    "  directory being that of the root build directory. If you pass\n"
+    "  to your script, see \"gn help to_build_path\" for how to convert\n"
+    "  file names to be relative to the build directory (file names in the\n"
+    "  sources, outputs, and source_prereqs will be all treated as relative\n"
+    "  to the current build file and converted as needed automatically).\n"
     "\n"
     "  There are two modes. The first mode is the \"per-file\" mode where you\n"
     "  specify a list of sources and the script is run once for each one as a\n"
     "  build rule. In this case, each file specified in the |outputs|\n"
     "  variable must be unique when applied to each source file (normally you\n"
     "  would reference |{{source_name_part}}| from within each one) or the\n"
     "  build system will get confused about how to build those files. You\n"
     "  should use the |source_prereqs| variable to list all additional\n"
     "  dependencies of your script: these will be added as dependencies for\n"
     "  each build step.\n"
     "\n"
     "  The second mode is when you just want to run a script once rather than\n"
     "  as a general rule over a set of files. In this case you don't list any\n"
     "  sources. Dependencies of your script are specified only in the\n"
     "  |source_prereqs| variable and your |outputs| variable should just list\n"
     "  all outputs.\n"
     "\n"
     "Variables:\n"
     "\n"
     "  args, deps, outputs, script*, source_prereqs, sources\n"
     "  * = required\n"
     "\n"
     "  There are some special substrings that will be searched for when\n"
     "  processing some variables:\n"
     "\n"
     "    {{source}}\n"
     "        Expanded in |args|, this is the name of the source file relative\n"
-    "        to the current directory when running the script. This is how\n"
-    "        you specify the current input file to your script.\n"
+    "        to the build directory This is how you specify the current input\n"
+    "        file to your script.\n"
     "\n"
     "    {{source_name_part}}\n"
     "        Expanded in |args| and |outputs|, this is just the filename part\n"
     "        of the current source file with no directory or extension. This\n"
     "        is how you specify a name transformation to the output. Normally\n"
     "        you would write an output as\n"
     "        \"$target_output_dir/{{source_name_part}}.o\".\n"
     "\n"
     "  All |outputs| files must be inside the output directory of the build.\n"
     "  You would generally use |$target_output_dir| or |$target_gen_dir| to\n"
     "  reference the output or generated intermediate file directories,\n"
     "  respectively.\n"
     "\n"
     "Examples:\n"
     "\n"
     "  # Runs the script over each IDL file. The IDL script will generate\n"
     "  # both a .cc and a .h file for each input.\n"
     "  custom(\"general_rule\") {\n"
     "    script = \"idl_processor.py\"\n"
     "    sources = [ \"foo.idl\", \"bar.idl\" ]\n"
     "    source_prereqs = [ \"my_configuration.txt\" ]\n"
     "    outputs = [ \"$target_gen_dir/{{source_name_part}}.h\",\n"
     "                \"$target_gen_dir/{{source_name_part}}.cc\" ]\n"
+    "\n"
+    "    # Note that since \"args\" is opaque to GN, if you specify paths\n"
+    "    # here, you will need to convert it to be relative to the build\n"
+    "    # directory using \"to_build_path()\".\n"
     "    args = [ \"{{source}}\",\n"
     "             \"-o\",\n"
-    "             \"$relative_target_gen_dir/{{source_name_part}}.h\" ]\n"
+    "             to_build_path(relative_target_gen_dir) + \"/\" +\n"
+    "                 {{source_name_part}}.h\" ]\n"
     "  }\n"
     "\n"
     "  custom(\"just_run_this_guy_once\") {\n"
     "    script = \"doprocessing.py\"\n"
     "    source_prereqs = [ \"my_configuration.txt\" ]\n"
     "    outputs = [ \"$target_gen_dir/insightful_output.txt\" ]\n"
-    "    args = [ \"--output_dir\", $target_gen_dir ]\n"
+    "    args = [ \"--output_dir\", to_build_path(target_gen_dir) ]\n"
     "  }\n";
 
 Value RunCustom(Scope* scope,
                 const FunctionCallNode* function,
                 const std::vector<Value>& args,
                 BlockNode* block,
                 Err* err) {
   return ExecuteGenericTarget(functions::kCustom, scope, function, args,
                               block, err);
 }
@@ skipping 112 matching lines @@
 Value RunTest(Scope* scope,
               const FunctionCallNode* function,
               const std::vector<Value>& args,
               BlockNode* block,
               Err* err) {
   return ExecuteGenericTarget(functions::kExecutable, scope, function, args,
                               block, err);
 }
 
 }  // namespace functions