GN generator for GYP actions

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/builder_record.h"
@@ skipping 12 matching lines @@
 struct Accumulator {
   Accumulator(std::vector<T>* result_in) : result(result_in) {}
 
   void operator()(const T& s, std::ostream&) const {
     result->push_back(s);
   }
 
   std::vector<T>* result;
 };
 
-// Standalone version of GypBinaryTargetWriter::Indent for use by standalone
-// functions.
-std::ostream& Indent(std::ostream& out, int spaces) {
-  const char kSpaces[81] =
-      "                                        "
-      "                                        ";
-  CHECK(static_cast<size_t>(spaces) <= arraysize(kSpaces) - 1);
-  out.write(kSpaces, spaces);
-  return out;
-}
-
 // Writes the given array values. The array should already be declared with the
 // opening "[" written to the output. The function will not write the
 // terminating "]" either.
 void WriteArrayValues(std::ostream& out,
                       const std::vector<std::string>& values) {
   EscapeOptions options;
   options.mode = ESCAPE_JSON;
   for (size_t i = 0; i < values.size(); i++) {
     out << " '";
     EscapeStringToStream(out, values[i], options);
     out << "',";
   }
 }
 
-// Writes the given array with the given name. The indent should be the
-// indenting for the name, the values will be indented 2 spaces from there.
-// Writes nothing if there is nothing in the array.
-void WriteNamedArray(std::ostream& out,
-                     const char* name,
-                     const std::vector<std::string>& values,
-                     int indent) {
-  if (values.empty())
-    return;
-
-  EscapeOptions options;
-  options.mode = ESCAPE_JSON;
-
-  Indent(out, indent) << "'" << name << "': [";
-  WriteArrayValues(out, values);
-  out << " ],\n";
-}
-
 // Returns the value from the already-filled in cflags_* for the optimization
 // level to set in the GYP file. Additionally, this removes the flag from the
 // given vector so we don't get duplicates.
 std::string GetVCOptimization(std::vector<std::string>* cflags) {
   // Searches for the "/O?" option and returns the corresponding GYP value.
   for (size_t i = 0; i < cflags->size(); i++) {
     const std::string& cur = (*cflags)[i];
     if (cur.size() == 3 && cur[0] == '/' && cur[1] == 'O') {
       char level = cur[2];
       cflags->erase(cflags->begin() + i);  // Invalidates |cur|!
@@ skipping 17 matching lines @@
     const std::vector<T>& (ConfigValues::* getter)() const,
     std::vector<T>* result) {
   for (size_t config_i = 0; config_i < configs.size(); config_i++) {
     const std::vector<T>& values =
         (configs[config_i].ptr->config_values().*getter)();
     for (size_t val_i = 0; val_i < values.size(); val_i++)
       result->push_back(values[val_i]);
   }
 }
 
-const int kExtraIndent = 2;
-
 }  // namespace
 
 GypBinaryTargetWriter::Flags::Flags() {}
 GypBinaryTargetWriter::Flags::~Flags() {}
 
 GypBinaryTargetWriter::GypBinaryTargetWriter(const TargetGroup& group,
+                                             const SourceDir& gyp_dir,
                                              std::ostream& out)
-    : GypTargetWriter(group.debug->item()->AsTarget(), out),
+    : GypTargetWriter(group.debug->item()->AsTarget(), gyp_dir, out),
       group_(group) {
 }
 
 GypBinaryTargetWriter::~GypBinaryTargetWriter() {
 }
 
 void GypBinaryTargetWriter::Run() {
   int indent = 4;
 
   Indent(indent) << "{\n";
 
   WriteName(indent + kExtraIndent);
   WriteType(indent + kExtraIndent);
 
   if (target_->settings()->IsLinux())
     WriteLinuxConfiguration(indent + kExtraIndent);
   else if (target_->settings()->IsWin())
     WriteVCConfiguration(indent + kExtraIndent);
   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);
-}
-
 void GypBinaryTargetWriter::WriteName(int indent) {
   std::string name = helper_.GetNameForTarget(target_);
   Indent(indent) << "'target_name': '" << name << "',\n";
 
   std::string product_name;
   if (target_->output_name().empty())
     product_name = target_->label().name();
   else
     product_name = name;
 
@@ skipping 111 matching lines @@
   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);
+  WriteNamedArray("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.
   // This can produce duplicate values. So look up the GYP value corresponding
   // to the flags used, and set the same one.
   std::string optimization = GetVCOptimization(&flags.cflags);
-  WriteNamedArray(out_, "AdditionalOptions", flags.cflags,
-                  indent + kExtraIndent * 2);
+  WriteNamedArray("AdditionalOptions", flags.cflags, indent + kExtraIndent * 2);
   // TODO(brettw) cflags_c and cflags_cc!
   Indent(indent + kExtraIndent * 2) << "'Optimization': "
                                     << optimization << ",\n";
   Indent(indent + kExtraIndent) << "},\n";
 
   // Linker tool stuff.
   Indent(indent + kExtraIndent) << "'VCLinkerTool': {\n";
 
   // ...Library dirs.
   EscapeOptions escape_options;
   escape_options.mode = ESCAPE_JSON;
   if (!flags.lib_dirs.empty()) {
     Indent(indent + kExtraIndent * 2) << "'AdditionalLibraryDirectories': [";
     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";
   }
 
   // ...Libraries.
-  WriteNamedArray(out_, "AdditionalDependencies", flags.libs,
+  WriteNamedArray("AdditionalDependencies", flags.libs,
                   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);
+  WriteNamedArray("AdditionalOptions", flags.ldflags, 14);
   Indent(indent + kExtraIndent) << "},\n";
   Indent(indent) << "},\n";
 }
 
 void GypBinaryTargetWriter::WriteMacFlags(Flags& flags, int indent) {
-  WriteNamedArray(out_, "defines", flags.defines, indent);
+  WriteNamedArray("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_,
@@ skipping 31 matching lines @@
     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);
-  }
+  if (target_->output_type() != Target::STATIC_LIBRARY)
+    WriteNamedArray("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";
 
   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);
-  WriteNamedArray(out_, "cflags_c",     flags.cflags_c,     indent);
-  WriteNamedArray(out_, "cflags_cc",    flags.cflags_cc,    indent);
-  WriteNamedArray(out_, "cflags_objc",  flags.cflags_objc,  indent);
-  WriteNamedArray(out_, "cflags_objcc", flags.cflags_objcc, indent);
+  WriteNamedArray("defines",      flags.defines,      indent);
+  WriteNamedArray("cflags",       flags.cflags,       indent);
+  WriteNamedArray("cflags_c",     flags.cflags_c,     indent);
+  WriteNamedArray("cflags_cc",    flags.cflags_cc,    indent);
+  WriteNamedArray("cflags_objc",  flags.cflags_objc,  indent);
+  WriteNamedArray("cflags_objcc", flags.cflags_objcc, indent);
 
   // Put libraries and library directories in with ldflags.
   Indent(indent) << "'ldflags': ["; \
   WriteArrayValues(out_, flags.ldflags);
 
   EscapeOptions escape_options;
   escape_options.mode = ESCAPE_JSON;
   for (size_t i = 0; i < flags.lib_dirs.size(); i++) {
     out_ << " '-L";
     EscapeStringToStream(out_,
@@ skipping 138 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;
 }
+
+void GypBinaryTargetWriter::WriteNamedArray(
+    const char* name,
+    const std::vector<std::string>& values,
+    int indent) {
+  if (values.empty())
+    return;
+
+  EscapeOptions options;
+  options.mode = ESCAPE_JSON;
+
+  Indent(indent) << "'" << name << "': [";
+  WriteArrayValues(out_, values);
+  out_ << " ],\n";
+}
+