[GN] Export include directories, defines and dialects to Xcode projects

tools/gn/xcode_object.cc

 // Copyright 2016 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/xcode_object.h"
 
 #include <iomanip>
 #include <sstream>
 #include <utility>
 
@@ skipping 204 matching lines @@
     out << pair.first << " = ";
     PrintValue(out, sub_rule, pair.second);
     out << ";" << (rules.one_line ? " " : "\n");
   }
 
   if (!rules.one_line && rules.level)
     out << std::string(rules.level, '\t');
   out << "}";
 }
 
+// Single entry values will by printed as value, multiple entries as vector
+template <typename ValueType>
+void PrintValue(std::ostream& out,
+                IndentRules rules,
+                const std::multimap<std::string, ValueType>& values) {
+  IndentRules sub_rule{rules.one_line, rules.level + 1};
+  out << "{" << (rules.one_line ? " " : "\n");
+
+  for (auto i = values.begin(); i != values.end();) {
+    if (!sub_rule.one_line)
+      out << std::string(sub_rule.level, '\t');
+    out << i->first << " = ";
+    auto upper = values.upper_bound(i->first);
+    std::vector<ValueType> values;
+    while (i != upper) {
+      values.push_back(i->second);
+      ++i;
+    }
+    if (values.size() == 1) {
+      PrintValue(out, sub_rule, values.front());
+    } else {
+      PrintValue(out, sub_rule, values);
+    }
+
+    out << ";" << (rules.one_line ? " " : "\n");
+  }
+
+  if (!rules.one_line && rules.level)
+    out << std::string(rules.level, '\t');
+  out << "}";
+}
+
 template <typename ValueType>
 void PrintProperty(std::ostream& out,
                    IndentRules rules,
                    const char* name,
                    ValueType&& value) {
   if (!rules.one_line && rules.level)
     out << std::string(rules.level, '\t');
 
   out << name << " = ";
   PrintValue(out, rules, std::forward<ValueType>(value));
@@ skipping 123 matching lines @@
   PrintProperty(out, rules, "buildPhases", build_phases_);
   PrintProperty(out, rules, "dependencies", EmptyPBXObjectVector());
   PrintProperty(out, rules, "name", name_);
   PrintProperty(out, rules, "productName", name_);
   out << indent_str << "};\n";
 }
 
 // PBXBuildFile ---------------------------------------------------------------
 
 PBXBuildFile::PBXBuildFile(const PBXFileReference* file_reference,
-                           const PBXSourcesBuildPhase* build_phase)
-    : file_reference_(file_reference), build_phase_(build_phase) {
+                           const PBXSourcesBuildPhase* build_phase,
+                           const std::string& cflags)
+    : file_reference_(file_reference),
+      build_phase_(build_phase),
+      cflags_(cflags) {
   DCHECK(file_reference_);
   DCHECK(build_phase_);
 }
 
 PBXBuildFile::~PBXBuildFile() {}
 
 PBXObjectClass PBXBuildFile::Class() const {
   return PBXBuildFileClass;
 }
 
 std::string PBXBuildFile::Name() const {
   return file_reference_->Name() + " in " + build_phase_->Name();
 }
 
 void PBXBuildFile::Print(std::ostream& out, unsigned indent) const {
   const std::string indent_str(indent, '\t');
   const IndentRules rules = {true, 0};
   out << indent_str << Reference() << " = {";
   PrintProperty(out, rules, "isa", ToString(Class()));
   PrintProperty(out, rules, "fileRef", file_reference_);
+  if (!cflags_.empty()) {
+    std::map<std::string, std::string> settings;
+    settings["COMPILER_FLAGS"] = cflags_;
+    PrintProperty(out, rules, "settings", settings);
+  }
   out << "};\n";
 }
 
 // PBXFileReference -----------------------------------------------------------
 
 PBXFileReference::PBXFileReference(const std::string& name,
                                    const std::string& path,
                                    const std::string& type)
     : name_(name), path_(path), type_(type) {}
 
@@ skipping 152 matching lines @@
   DCHECK(product_reference_);
   build_phases_.push_back(base::WrapUnique(new PBXSourcesBuildPhase));
   source_build_phase_ =
       static_cast<PBXSourcesBuildPhase*>(build_phases_.back().get());
 
   build_phases_.push_back(base::WrapUnique(new PBXFrameworksBuildPhase));
 }
 
 PBXNativeTarget::~PBXNativeTarget() {}
 
-void PBXNativeTarget::AddFileForIndexing(
-    const PBXFileReference* file_reference) {
+void PBXNativeTarget::AddFileForIndexing(const PBXFileReference* file_reference,
+                                         const std::string& cflags) {
   DCHECK(file_reference);
-  source_build_phase_->AddBuildFile(
-      base::WrapUnique(new PBXBuildFile(file_reference, source_build_phase_)));
+  source_build_phase_->AddBuildFile(base::WrapUnique(
+      new PBXBuildFile(file_reference, source_build_phase_, cflags)));
 }
 
 PBXObjectClass PBXNativeTarget::Class() const {
   return PBXNativeTargetClass;
 }
 
 void PBXNativeTarget::Print(std::ostream& out, unsigned indent) const {
   const std::string indent_str(indent, '\t');
   const IndentRules rules = {false, indent + 1};
   out << indent_str << Reference() << " = {\n";
   PrintProperty(out, rules, "isa", ToString(Class()));
   PrintProperty(out, rules, "buildConfigurationList", configurations_);
   PrintProperty(out, rules, "buildPhases", build_phases_);
   PrintProperty(out, rules, "buildRules", EmptyPBXObjectVector());
   PrintProperty(out, rules, "dependencies", EmptyPBXObjectVector());
   PrintProperty(out, rules, "name", name_);
   PrintProperty(out, rules, "productName", product_name_);
   PrintProperty(out, rules, "productReference", product_reference_);
   PrintProperty(out, rules, "productType", product_type_);
   out << indent_str << "};\n";
 }
 
 // PBXProject -----------------------------------------------------------------
 
 PBXProject::PBXProject(const std::string& name,
                        const std::string& config_name,
                        const std::string& source_path,
                        const PBXAttributes& attributes)
     : name_(name), config_name_(config_name), target_for_indexing_(nullptr) {
-  attributes_["BuildIndependentTargetsInParallel"] = "YES";
+  if (attributes_.find("BuildIndependentTargetsInParallel") ==
+      attributes_.end())
+    attributes_.insert(
+        std::make_pair("BuildIndependentTargetsInParallel", "YES"));
 
   main_group_.reset(new PBXGroup);
   sources_ = static_cast<PBXGroup*>(main_group_->AddChild(
       base::WrapUnique(new PBXGroup(source_path, "Source"))));
   products_ = static_cast<PBXGroup*>(main_group_->AddChild(
       base::WrapUnique(new PBXGroup(std::string(), "Product"))));
   main_group_->AddChild(base::WrapUnique(new PBXGroup(std::string(), "Build")));
 
   configurations_.reset(new XCConfigurationList(config_name, attributes, this));
 }
 
 PBXProject::~PBXProject() {}
 
-void PBXProject::AddSourceFile(const std::string& source_path) {
+bool PBXProject::SourceFileShouldBeIndexed(const std::string& source_path) {
+  base::StringPiece ext = FindExtension(&source_path);
+  return IsSourceFileForIndexing(ext);
+}
+
+void PBXProject::AddSourceFile(const std::string& source_path,
+                               const std::string& cflags) {
   PBXFileReference* file_reference = sources_->AddSourceFile(source_path);
-  base::StringPiece ext = FindExtension(&source_path);
-  if (!IsSourceFileForIndexing(ext))
+  if (!SourceFileShouldBeIndexed(source_path))
     return;
 
   if (!target_for_indexing_) {
     PBXAttributes attributes;
-    attributes["EXECUTABLE_PREFIX"] = "";
-    attributes["HEADER_SEARCH_PATHS"] = sources_->path();
-    attributes["PRODUCT_NAME"] = name_;
+    attributes.insert(std::make_pair("EXECUTABLE_PREFIX", ""));
+    attributes.insert(std::make_pair("PRODUCT_NAME", name_));
 
     PBXFileReference* product_reference = static_cast<PBXFileReference*>(
         products_->AddChild(base::WrapUnique(new PBXFileReference(
             std::string(), name_, "compiled.mach-o.executable"))));
 
     const char product_type[] = "com.apple.product-type.tool";
     targets_.push_back(base::WrapUnique(
         new PBXNativeTarget(name_, std::string(), config_name_, attributes,
                             product_type, name_, product_reference)));
     target_for_indexing_ = static_cast<PBXNativeTarget*>(targets_.back().get());
   }
 
   DCHECK(target_for_indexing_);
-  target_for_indexing_->AddFileForIndexing(file_reference);
+  target_for_indexing_->AddFileForIndexing(file_reference, cflags);
 }
 
 void PBXProject::AddAggregateTarget(const std::string& name,
                                     const std::string& shell_script) {
   PBXAttributes attributes;
-  attributes["CODE_SIGNING_REQUIRED"] = "NO";
-  attributes["CONFIGURATION_BUILD_DIR"] = ".";
-  attributes["PRODUCT_NAME"] = name;
+  attributes.insert(std::make_pair("CODE_SIGNING_REQUIRED", "NO"));
+  attributes.insert(std::make_pair("CONFIGURATION_BUILD_DIR", "."));
+  attributes.insert(std::make_pair("PRODUCT_NAME", name));
 
   targets_.push_back(base::WrapUnique(
       new PBXAggregateTarget(name, shell_script, config_name_, attributes)));
 }
 
 void PBXProject::AddNativeTarget(const std::string& name,
                                  const std::string& type,
                                  const std::string& output_name,
                                  const std::string& output_type,
                                  const std::string& shell_script) {
   base::StringPiece ext = FindExtension(&output_name);
   PBXFileReference* product =
       static_cast<PBXFileReference*>(products_->AddChild(base::WrapUnique(
           new PBXFileReference(std::string(), output_name,
                                type.empty() ? GetSourceType(ext) : type))));
 
   size_t ext_offset = FindExtensionOffset(output_name);
   std::string product_name = ext_offset != std::string::npos
                                  ? output_name.substr(0, ext_offset - 1)
                                  : output_name;
 
   PBXAttributes attributes;
-  attributes["CODE_SIGNING_REQUIRED"] = "NO";
-  attributes["CONFIGURATION_BUILD_DIR"] = ".";
-  attributes["PRODUCT_NAME"] = product_name;
+  attributes.insert(std::make_pair("CODE_SIGNING_REQUIRED", "NO"));
+  attributes.insert(std::make_pair("CONFIGURATION_BUILD_DIR", "."));
+  attributes.insert(std::make_pair("PRODUCT_NAME", product_name));
 
   targets_.push_back(base::WrapUnique(
       new PBXNativeTarget(name, shell_script, config_name_, attributes,
                           output_type, product_name, product)));
 }
 
 void PBXProject::SetProjectDirPath(const std::string& project_dir_path) {
   DCHECK(!project_dir_path.empty());
   project_dir_path_.assign(project_dir_path);
 }
@@ skipping 181 matching lines @@
   const std::string indent_str(indent, '\t');
   const IndentRules rules = {false, indent + 1};
   out << indent_str << Reference() << " = {\n";
   PrintProperty(out, rules, "isa", ToString(Class()));
   PrintProperty(out, rules, "buildConfigurations", configurations_);
   PrintProperty(out, rules, "defaultConfigurationIsVisible", 1u);
   PrintProperty(out, rules, "defaultConfigurationName",
                 configurations_[0]->Name());
   out << indent_str << "};\n";
 }