Windows precompiled header support in GN

tools/gn/function_toolchain.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 <algorithm>
 #include <limits>
 
 #include "tools/gn/err.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/parse_tree.h"
@@ skipping 96 matching lines @@
 
   if (value->string_value()[0] != '.') {
     *err = Err(*value, "default_output_extension must begin with a '.'");
     return false;
   }
 
   tool->set_default_output_extension(value->string_value());
   return true;
 }
 
+bool ReadPrecompiledHeaderType(Scope* scope, Tool* tool, Err* err) {
+  const Value* value = scope->GetValue("precompiled_header_type", true);
+  if (!value)
+    return true;  // Not present is fine.
+  if (!value->VerifyTypeIs(Value::STRING, err))
+    return false;
+
+  if (value->string_value().empty())
+    return true;  // Accept empty string, do nothing (default is "no PCH").
+
+  if (value->string_value() == "msvc") {
+    tool->set_precompiled_header_type(Tool::PCH_MSVC);
+    return true;
+  }
+  *err = Err(*value, "Invalid precompiled_header_type",
+             "Must either be empty or \"msvc\".");
+  return false;
+}
+
 bool ReadDepsFormat(Scope* scope, Tool* tool, Err* err) {
   const Value* value = scope->GetValue("depsformat", true);
   if (!value)
     return true;  // Not present is fine.
   if (!value->VerifyTypeIs(Value::STRING, err))
     return false;
 
   if (value->string_value() == "gcc") {
     tool->set_depsformat(Tool::DEPS_GCC);
   } else if (value->string_value() == "msvc") {
@@ skipping 369 matching lines @@
     "        Prefix to use for the output name. Defaults to empty. This\n"
     "        prefix will be prepended to the name of the target (or the\n"
     "        output_name if one is manually specified for it) if the prefix\n"
     "        is not already there. The result will show up in the\n"
     "        {{output_name}} substitution pattern.\n"
     "\n"
     "        This is typically used to prepend \"lib\" to libraries on\n"
     "        Posix systems:\n"
     "          output_prefix = \"lib\"\n"
     "\n"
+    "    precompiled_header_type  [string]\n"
+    "        Valid for: \"cc\", \"cxx\", \"objc\", \"objcxx\"\n"
+    "\n"
+    "        Type of precompiled headers. If undefined or the empty string,\n"
+    "        precompiled headers will not be used for this tool. Otherwise\n"
+    "        use \"msvc\" which is the only currently supported value.\n"
+    "\n"
+    "        For precompiled headers to be used for a given target, the\n"
+    "        target (or a config applied to it) must also specify a\n"
+    "        \"precompiled_header\" and, for \"msvc\"-style headers, a\n"
+    "        \"precompiled_source\" value.\n"
+    "\n"
+    "        See \"gn help precompiled_header\" for more.\n"
+    "\n"
     "    restat  [boolean]\n"
     "        Valid for: all tools (optional, defaults to false)\n"
     "\n"
     "        Requests that Ninja check the file timestamp after this tool has\n"
     "        run to determine if anything changed. Set this if your tool has\n"
     "        the ability to skip writing output if the output file has not\n"
     "        changed.\n"
     "\n"
     "        Normally, Ninja will assume that when a tool runs the output\n"
     "        be new and downstream dependents must be rebuild. When this is\n"
@@ skipping 17 matching lines @@
     "        allows you to get around OS command-line length limits.\n"
     "\n"
     "        This example adds the inputs and libraries to a response file,\n"
     "        but passes the linker flags directly on the command line:\n"
     "          tool(\"link\") {\n"
     "            command = \"link -o {{output}} {{ldflags}} @{{output}}.rsp\"\n"
     "            rspfile = \"{{output}}.rsp\"\n"
     "            rspfile_content = \"{{inputs}} {{solibs}} {{libs}}\"\n"
     "          }\n"
     "\n"
-    "Expansions for tool variables"
+    "Expansions for tool variables\n"
     "\n"
     "  All paths are relative to the root build directory, which is the\n"
     "  current directory for running all tools. These expansions are\n"
     "  available to all tools:\n"
     "\n"
     "    {{label}}\n"
     "        The label of the current target. This is typically used in the\n"
     "        \"description\" field for link tools. The toolchain will be\n"
     "        omitted from the label for targets in the default toolchain, and\n"
     "        will be included for targets in other toolchains.\n"
@@ skipping 223 matching lines @@
       !ReadString(&block_scope, "lib_switch", tool.get(),
                   &Tool::set_lib_switch, err) ||
       !ReadString(&block_scope, "lib_dir_switch", tool.get(),
                   &Tool::set_lib_dir_switch, err) ||
       !ReadPattern(&block_scope, "link_output", subst_validator, tool.get(),
                    &Tool::set_link_output, err) ||
       !ReadPattern(&block_scope, "depend_output", subst_validator, tool.get(),
                    &Tool::set_depend_output, err) ||
       !ReadString(&block_scope, "output_prefix", tool.get(),
                   &Tool::set_output_prefix, err) ||
+      !ReadPrecompiledHeaderType(&block_scope, tool.get(), err) ||
       !ReadBool(&block_scope, "restat", tool.get(), &Tool::set_restat, err) ||
       !ReadPattern(&block_scope, "rspfile", subst_validator, tool.get(),
                    &Tool::set_rspfile, err) ||
       !ReadPattern(&block_scope, "rspfile_content", subst_validator, tool.get(),
                    &Tool::set_rspfile_content, err)) {
     return Value();
   }
 
   if (tool_type != Toolchain::TYPE_COPY && tool_type != Toolchain::TYPE_STAMP) {
     // All tools except the copy and stamp tools should have outputs. The copy
@@ skipping 114 matching lines @@
     return Value();
 
   Scope::KeyValueMap values;
   block_scope.GetCurrentScopeValues(&values);
   toolchain->args() = values;
 
   return Value();
 }
 
 }  // namespace functions