Work on GN iOS build.

tools/gn/gyp_binary_target_writer.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/gyp_binary_target_writer.h"
 
 #include <set>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
@@ skipping 99 matching lines @@
 
 }  // namespace
 
 GypBinaryTargetWriter::Flags::Flags() {}
 GypBinaryTargetWriter::Flags::~Flags() {}
 
 GypBinaryTargetWriter::GypBinaryTargetWriter(const TargetGroup& group,
                                              const Toolchain* debug_toolchain,
                                              const SourceDir& gyp_dir,
                                              std::ostream& out)
-    : GypTargetWriter(group.debug->item()->AsTarget(), debug_toolchain,
+    : GypTargetWriter(group.get()->item()->AsTarget(), debug_toolchain,
                       gyp_dir, out),
       group_(group) {
 }
 
 GypBinaryTargetWriter::~GypBinaryTargetWriter() {
 }
 
 void GypBinaryTargetWriter::Run() {
   int indent = 4;
 
@@ skipping 45 matching lines @@
       break;
     case Target::SOURCE_SET:
       out_ << "'static_library',\n";  // TODO(brettw) fixme.
       break;
     default:
       NOTREACHED();
   }
 
   if (target_->hard_dep())
     Indent(indent) << "'hard_dependency': 1,\n";
+
+  // Write out the toolsets depending on whether there is a host build. If no
+  // toolset is specified, GYP assumes a target build.
+  if (group_.debug && group_.host_debug)
+    Indent(indent) << "'toolsets': ['target', 'host'],\n";
+  else if (group_.host_debug)
+    Indent(indent) << "'toolsets': ['host'],\n";
 }
 
 void GypBinaryTargetWriter::WriteVCConfiguration(int indent) {
   Indent(indent) << "'configurations': {\n";
 
   Indent(indent + kExtraIndent) << "'Debug': {\n";
   Indent(indent + kExtraIndent * 2) <<
       "'msvs_configuration_platform': 'Win32',\n";
   Flags debug_flags(FlagsFromTarget(group_.debug->item()->AsTarget()));
   WriteVCFlags(debug_flags, indent + kExtraIndent * 2);
@@ skipping 75 matching lines @@
   WriteSources(target_, indent + kExtraIndent * 2);
 
   Indent(indent + kExtraIndent) << "},],\n";
   Indent(indent) << "],\n";
 
   // Deps in GYP can not vary based on the toolset.
   WriteDeps(target_, indent);
 }
 
 void GypBinaryTargetWriter::WriteMacConfiguration(int indent) {
+  // The Mac flags are parameterized by the GYP generator (Ninja vs. XCode).
+  const char kNinjaGeneratorCondition[] =
+      "'conditions': [['\"<(GENERATOR)\"==\"ninja\"', {\n";
+  const char kNinjaGeneratorElse[] = "}, {\n";
+  const char kNinjaGeneratorEnd[] = "}]],\n";
+
   Indent(indent) << "'configurations': {\n";
 
+  // Debug.
   Indent(indent + kExtraIndent) << "'Debug': {\n";
-  Flags debug_flags(FlagsFromTarget(group_.debug->item()->AsTarget()));
-  WriteMacFlags(debug_flags, indent + kExtraIndent * 2);
+  Indent(indent + kExtraIndent * 2) << kNinjaGeneratorCondition;
+  {
+    // Ninja generator.
+    WriteMacTargetAndHostFlags(group_.debug, group_.host_debug,
+                               indent + kExtraIndent * 3);
+  }
+  Indent(indent + kExtraIndent * 2) << kNinjaGeneratorElse;
+  if (group_.xcode_debug) {
+    // XCode generator.
+    WriteMacTargetAndHostFlags(group_.xcode_debug, group_.xcode_host_debug,
+                               indent + kExtraIndent * 3);
+  }
+  Indent(indent + kExtraIndent * 2) << kNinjaGeneratorEnd;
   Indent(indent + kExtraIndent) << "},\n";
 
+  // Release.
   Indent(indent + kExtraIndent) << "'Release': {\n";
-  Flags release_flags(FlagsFromTarget(group_.release->item()->AsTarget()));
-  WriteMacFlags(release_flags, indent + kExtraIndent * 2);
+  Indent(indent + kExtraIndent * 2) << kNinjaGeneratorCondition;
+  {
+    // Ninja generator.
+    WriteMacTargetAndHostFlags(group_.release, group_.host_release,
+                               indent + kExtraIndent * 3);
+  }
+  Indent(indent + kExtraIndent * 2) << kNinjaGeneratorElse;
+  if (group_.xcode_release) {
+    // XCode generator.
+    WriteMacTargetAndHostFlags(group_.xcode_release, group_.xcode_host_release,
+                               indent + kExtraIndent * 3);
+  }
+  Indent(indent + kExtraIndent * 2) << kNinjaGeneratorEnd;
   Indent(indent + kExtraIndent) << "},\n";
 
   Indent(indent) << "},\n";
 
   WriteSources(target_, indent);
   WriteDeps(target_, indent);
 }
 
 void GypBinaryTargetWriter::WriteVCFlags(Flags& flags, int indent) {
   // Defines and includes go outside of the msvs settings.
@@ skipping 120 matching lines @@
       target_->settings()->base_config()->GetValue("is_clang");
   if (is_clang && is_clang->type() == Value::BOOLEAN &&
       is_clang->boolean_value()) {
     base::FilePath clang_path =
         target_->settings()->build_settings()->GetFullPath(SourceFile(
             "//third_party/llvm-build/Release+Asserts/bin/clang"));
     base::FilePath clang_pp_path =
         target_->settings()->build_settings()->GetFullPath(SourceFile(
             "//third_party/llvm-build/Release+Asserts/bin/clang++"));
 
-    Indent(indent) << "'CC': '" << FilePathToUTF8(clang_path) << "',\n";
-    Indent(indent) << "'LDPLUSPLUS': '"
-                   << FilePathToUTF8(clang_pp_path) << "',\n";
+    Indent(indent + kExtraIndent)
+        << "'CC': '" << FilePathToUTF8(clang_path) << "',\n";
+    Indent(indent + kExtraIndent)
+        << "'LDPLUSPLUS': '" << FilePathToUTF8(clang_pp_path) << "',\n";
   }
 
   Indent(indent) << "},\n";
 }
 
 void GypBinaryTargetWriter::WriteLinuxFlagsForTarget(const Target* target,
                                                      int indent) {
   Flags flags(FlagsFromTarget(target));
   WriteLinuxFlags(flags, indent);
 }
@@ skipping 22 matching lines @@
   }
 
   for (size_t i = 0; i < flags.libs.size(); i++) {
     out_ << " '-l";
     EscapeStringToStream(out_, flags.libs[i], escape_options);
     out_ << "',";
   }
   out_ << " ],\n";
 }
 
+void GypBinaryTargetWriter::WriteMacTargetAndHostFlags(
+    const BuilderRecord* target,
+    const BuilderRecord* host,
+    int indent) {
+  // The Mac flags are sometimes (when cross-compiling) also parameterized on
+  // the toolset.
+  const char kToolsetTargetCondition[] =
+      "'target_conditions': [['_toolset==\"target\"', {\n";
+  const char kToolsetTargetElse[] = "}, {\n";
+  const char kToolsetTargetEnd[] = "}]],\n";
+
+  int extra_indent = 0;
+  if (host) {
+    // Write out the first part of the conditional.
+    Indent(indent) << kToolsetTargetCondition;
+    extra_indent = kExtraIndent;
+  }
+
+  // Always write the target flags (may or may not be inside a target
+  // conditional).
+  {
+    Flags flags(FlagsFromTarget(target->item()->AsTarget()));
+    WriteMacFlags(flags, indent + extra_indent);
+  }
+
+  // Now optionally write the host conditional arm.
+  if (host) {
+    Indent(indent) << kToolsetTargetElse;
+    Flags flags(FlagsFromTarget(host->item()->AsTarget()));
+    WriteMacFlags(flags, indent + kExtraIndent);
+    Indent(indent) << kToolsetTargetEnd;
+  }
+}
+
 void GypBinaryTargetWriter::WriteSources(const Target* target, int indent) {
   Indent(indent) << "'sources': [\n";
 
   const Target::FileList& sources = target->sources();
   for (size_t i = 0; i < sources.size(); i++) {
     const SourceFile& input_file = sources[i];
     Indent(indent + kExtraIndent) << "'" << helper_.GetFileReference(input_file)
                                   << "',\n";
   }
 
@@ skipping 131 matching lines @@
     return;
 
   EscapeOptions options;
   options.mode = ESCAPE_JSON;
 
   Indent(indent) << "'" << name << "': [";
   WriteArrayValues(out_, values);
   out_ << " ],\n";
 }