GN Mac build work

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 "tools/gn/config_values_extractors.h"
 #include "tools/gn/err.h"
 #include "tools/gn/escape.h"
+#include "tools/gn/filesystem_utils.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/target.h"
 
 namespace {
 
 // This functor is used to capture the output of RecursiveTargetConfigToStream
 // in an vector.
 template<typename T>
 struct Accumulator {
   Accumulator(std::vector<T>* result_in) : result(result_in) {}
@@ skipping 102 matching lines @@
 }
 
 void GypBinaryTargetWriter::Run() {
   int indent = 4;
 
   Indent(indent) << "{\n";
 
   WriteName(indent + kExtraIndent);
   WriteType(indent + kExtraIndent);
 
-  if (target_->settings()->IsLinux()) {
+  if (target_->settings()->IsLinux())
     WriteLinuxConfiguration(indent + kExtraIndent);
-  } else if (target_->settings()->IsWin()) {
+  else if (target_->settings()->IsWin())
     WriteVCConfiguration(indent + kExtraIndent);
-  } else if (target_->settings()->IsMac()) {
-    // TODO(brettw) mac.
-    NOTREACHED();
-    //WriteMacConfiguration();
-  }
+  else if (target_->settings()->IsMac())
+    WriteMacConfiguration(indent + kExtraIndent);
   WriteDirectDependentSettings(indent + kExtraIndent);
   WriteAllDependentSettings(indent + kExtraIndent);
 
   Indent(indent) << "},\n";
 }
 
 std::ostream& GypBinaryTargetWriter::Indent(int spaces) {
   return ::Indent(out_, spaces);
 }
 
@@ skipping 95 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) {
+  Indent(indent) << "'configurations': {\n";
+
+  Indent(indent + kExtraIndent) << "'Debug': {\n";
+  Flags debug_flags(FlagsFromTarget(group_.debug));
+  WriteMacFlags(debug_flags, indent + kExtraIndent * 2);
+  Indent(indent + kExtraIndent) << "},\n";
+
+  Indent(indent + kExtraIndent) << "'Release': {\n";
+  Flags release_flags(FlagsFromTarget(group_.release));
+  WriteMacFlags(release_flags, indent + kExtraIndent * 2);
+  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.
   WriteNamedArray(out_, "defines", flags.defines, indent);
   WriteIncludeDirs(flags, indent);
 
   // C flags.
   Indent(indent) << "'msvs_settings': {\n";
   Indent(indent + kExtraIndent) << "'VCCLCompilerTool': {\n";
 
   // GYP always uses the VC optimization flag to add a /O? on Visual Studio.
@@ skipping 30 matching lines @@
                   indent + kExtraIndent * 2);
 
   // ...LD flags.
   // TODO(brettw) EnableUAC defaults to on and needs to be set. Also
   // UACExecutionLevel and UACUIAccess depends on that and defaults to 0/false.
   WriteNamedArray(out_, "AdditionalOptions", flags.ldflags, 14);
   Indent(indent + kExtraIndent) << "},\n";
   Indent(indent) << "},\n";
 }
 
+void GypBinaryTargetWriter::WriteMacFlags(Flags& flags, int indent) {
+  WriteNamedArray(out_, "defines", flags.defines, indent);
+  WriteIncludeDirs(flags, indent);
+
+  // Libraries and library directories.
+  EscapeOptions escape_options;
+  escape_options.mode = ESCAPE_JSON;
+  if (!flags.lib_dirs.empty()) {
+    Indent(indent + kExtraIndent) << "'library_dirs': [";
+    for (size_t i = 0; i < flags.lib_dirs.size(); i++) {
+      out_ << " '";
+      EscapeStringToStream(out_,
+                           helper_.GetDirReference(flags.lib_dirs[i], false),
+                           escape_options);
+      out_ << "',";
+    }
+    out_ << " ],\n";
+  }
+  if (!flags.libs.empty()) {
+    Indent(indent) << "'link_settings': {\n";
+    Indent(indent + kExtraIndent) << "'libraries': [";
+    for (size_t i = 0; i < flags.libs.size(); i++) {
+      out_ << " '-l";
+      EscapeStringToStream(out_, flags.libs[i], escape_options);
+      out_ << "',";
+    }
+    out_ << " ],\n";
+    Indent(indent) << "},\n";
+  }
+
+  Indent(indent) << "'xcode_settings': {\n";
+
+  // C/C++ flags.
+  if (!flags.cflags.empty() || !flags.cflags_c.empty() ||
+      !flags.cflags_objc.empty()) {
+    Indent(indent + kExtraIndent) << "'OTHER_CFLAGS': [";
+    WriteArrayValues(out_, flags.cflags);
+    WriteArrayValues(out_, flags.cflags_c);
+    WriteArrayValues(out_, flags.cflags_objc);

[Nico, 2013/10/28 23:05:14]

OTHER_CFLAGS is used for both C and Obj-C flags.

I was worried that the compiler would warn when seeing an Obj-C flag on a .c
compilation, but apparently that's not the case. It'll make the c and cc compile
commands a bit longer than they need to be though.

One way around that would be to map the handful of objc-only flags (-fobjc-arc ,
-fobjc-gc / -fobjc-gc-only, -Wobjc-missing-property-synthesis,
-fobjc-call-cxx-cdtors) to their corresponding explicit xcode_settings entries
(CLANG_ENABLE_OBJC_ARC, GCC_ENABLE_OBJC_GC,
CLANG_WARN_OBJC_MISSING_PROPERTY_SYNTHESIS, GCC_OBJC_CALL_CXX_CDTORS) but I
think it should be fine as-is too.

+    out_ << " ],\n";
+  }
+  if (!flags.cflags.empty() || !flags.cflags_cc.empty() ||
+      !flags.cflags_objcc.empty()) {
+    Indent(indent + kExtraIndent) << "'OTHER_CPLUSPLUSFLAGS': [";
+    WriteArrayValues(out_, flags.cflags);
+    WriteArrayValues(out_, flags.cflags_cc);
+    WriteArrayValues(out_, flags.cflags_objcc);
+    out_ << " ],\n";
+  }
+
+  // Ld flags. Don't write these for static libraries. Otherwise, they'll be
+  // passed to the library tool which doesn't expect it (the toolchain does
+  // not use ldflags so these are ignored in the normal build).
+  if (target_->output_type() != Target::STATIC_LIBRARY) {
+    WriteNamedArray(out_, "OTHER_LDFLAGS", flags.ldflags,
+                    indent + kExtraIndent);
+  }
+
+  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";

[Nico, 2013/10/28 23:05:14]

gyp's ninja generator doesn't use CC and LDPLUSPLUS but instead uses the
make_global_settings block that it uses on other platforms (yes, that's a bit
inconsistent). So you might want to write that too.

+
+  Indent(indent) << "},\n";
+}
+
 void GypBinaryTargetWriter::WriteLinuxFlagsForTarget(const Target* target,
                                                      int indent) {
   Flags flags(FlagsFromTarget(target));
   WriteLinuxFlags(flags, indent);
 }
 
 void GypBinaryTargetWriter::WriteLinuxFlags(const Flags& flags, int indent) {
   WriteIncludeDirs(flags, indent);
   WriteNamedArray(out_, "defines",      flags.defines,      indent);
   WriteNamedArray(out_, "cflags",       flags.cflags,       indent);
@@ skipping 72 matching lines @@
   }
   out_ << " ],\n";
 }
 
 void GypBinaryTargetWriter::WriteDirectDependentSettings(int indent) {
   if (target_->direct_dependent_configs().empty())
     return;
   out_ << "'direct_dependent_settings': {\n";
 
   Flags flags(FlagsFromConfigList(target_->direct_dependent_configs()));
-  if (target_->settings()->IsLinux()) {
+  if (target_->settings()->IsLinux())
     WriteLinuxFlags(flags, indent + kExtraIndent);
-  } else if (target_->settings()->IsWin()) {
+  else if (target_->settings()->IsWin())
     WriteVCFlags(flags, indent + kExtraIndent);
-  } else if (target_->settings()->IsMac()) {
-    // TODO(brettw) write mac.
-    NOTREACHED();
-  }
+  else if (target_->settings()->IsMac())
+    WriteMacFlags(flags, indent + kExtraIndent);
   Indent(indent) << "},\n";
 }
 
 void GypBinaryTargetWriter::WriteAllDependentSettings(int indent) {
   if (target_->all_dependent_configs().empty())
     return;
   Indent(indent) << "'all_dependent_settings': {\n";
 
   Flags flags(FlagsFromConfigList(target_->all_dependent_configs()));
-  if (target_->settings()->IsLinux()) {
+  if (target_->settings()->IsLinux())
     WriteLinuxFlags(flags, indent + kExtraIndent);
-  } else if (target_->settings()->IsWin()) {
+  else if (target_->settings()->IsWin())
     WriteVCFlags(flags, indent + kExtraIndent);
-  } else if (target_->settings()->IsMac()) {
-    // TODO(brettw) write mac.
-    NOTREACHED();
-  }
+  else if (target_->settings()->IsMac())
+    WriteMacFlags(flags, indent + kExtraIndent);
   Indent(indent) << "},\n";
 }
 
 GypBinaryTargetWriter::Flags GypBinaryTargetWriter::FlagsFromTarget(
     const Target* target) const {
   Flags ret;
 
   // Extracts a vector of the given type and name from the config values.
   #define EXTRACT(type, name) \
       { \
@@ skipping 39 matching lines @@
   EXTRACT(std::string, cflags_objc);
   EXTRACT(std::string, cflags_objcc);
   EXTRACT(std::string, ldflags);
   EXTRACT(SourceDir,   lib_dirs);
   EXTRACT(std::string, libs);
 
   #undef EXTRACT
 
   return ret;
 }