[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 << "}";
 }
 
+struct BuildSettingsValue
+{
+  BuildSettingsValue(const std::string &s) : value(s) { }
+  std::string value;
+};
+
+// Build settings can contain multiple values represented by multiline string
+void PrintValue(std::ostream& out,
+                IndentRules rules,
+                const BuildSettingsValue & buildSettingValue) {
+  const auto & value = buildSettingValue.value;
+  if (value.find('\n') == std::string::npos) {
+    PrintValue(out, rules, value);
+  } else {
+    // split and print as vector

[matt.k, 2016/06/10 07:35:11]

Splitting the string to get multiple values is a hack, I'll fix this properly.

+    std::vector<std::string> values;
+    std::size_t start = 0, end = 0;
+    while ((end = value.find('\n', start)) != std::string::npos) {
+      std::string sub = value.substr(start, end - start);
+      if (!sub.empty()) values.push_back(sub);
+      start = end + 1;
+    }
+    std::string last = value.substr(start);
+    if (!last.empty()) {
+        values.push_back(last);
+    }
+    PrintValue(out, rules, values);
+  }
+}
+
 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_)));
+      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";
@@ skipping 23 matching lines @@
       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_;
 
     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;
 
   targets_.push_back(base::WrapUnique(
@@ skipping 166 matching lines @@
 
 std::string XCBuildConfiguration::Name() const {
   return name_;
 }
 
 void XCBuildConfiguration::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, "buildSettings", attributes_);
+  std::map<std::string, BuildSettingsValue> build_settings;

[sdefresne, 2016/06/10 08:52:34]

I would use a multimap instead of splitting using the BuildSettingsValue hack.

+  for (const auto & pair : attributes_) {
+    build_settings.emplace(std::make_pair(pair.first,
+                                          BuildSettingsValue(pair.second)));
+  }
+  PrintProperty(out, rules, "buildSettings", build_settings);
   PrintProperty(out, rules, "name", name_);
   out << indent_str << "};\n";
 }
 
 // XCConfigurationList --------------------------------------------------------
 
 XCConfigurationList::XCConfigurationList(const std::string& name,
                                          const PBXAttributes& attributes,
                                          const PBXObject* owner_reference)
     : owner_reference_(owner_reference) {
@@ skipping 27 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";
 }