GN build fixes, mostly for Mac.

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"
 #include "tools/gn/builder_record.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 {
 
@@ skipping 39 matching lines @@
         case '1': return "'1'";
         case '2': return "'2'";
         case 'x': return "'3'";
         default:  return "'2'";
       }
     }
   }
   return "'2'";  // Default value.
 }
 
+// Returns the value from the already-filled in cflags for the processor
+// architecture to set in the GYP file. Additionally, this removes the flag
+// from the given vector so we don't get duplicates.
+std::string GetMacArch(std::vector<std::string>* cflags) {
+  // Searches for the "-arch" option and returns the corresponding GYP value.
+  for (size_t i = 0; i < cflags->size(); i++) {
+    const std::string& cur = (*cflags)[i];
+    if (cur == "-arch") {
+      // This is the first part of a list with ["-arch", "i386"], return the
+      // following item, and delete both of them.
+      if (i < cflags->size() - 1) {
+        std::string ret = (*cflags)[i + 1];
+        cflags->erase(cflags->begin() + i, cflags->begin() + i + 2);
+        return ret;
+      }
+    } else if (StartsWithASCII(cur, "-arch ", true)) {
+      // The arch was passed as one GN string value, e.g. "-arch i386". Return
+      // the stuff following the space and delete the item.
+      std::string ret = cur.substr(6);
+      cflags->erase(cflags->begin() + i);
+      return ret;
+    }
+  }
+  return std::string();
+}
+
 // Finds all values from the given getter from all configs in the given list,
 // and adds them to the given result vector.
 template<typename T>
 void FillConfigListValues(
     const LabelConfigVector& configs,
     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)();
@@ skipping 264 matching lines @@
       out_ << " '-l";
       EscapeStringToStream(out_, flags.libs[i], escape_options);
       out_ << "',";
     }
     out_ << " ],\n";
     Indent(indent) << "},\n";
   }
 
   Indent(indent) << "'xcode_settings': {\n";
 
+  // Architecture. GYP uses this to write the -arch flag passed to the
+  // compiler, it doesn't look at our -arch flag. So we need to specify it in
+  // this special var and not in the cflags to avoid duplicates or conflicts.
+  std::string arch = GetMacArch(&flags.cflags);
+  if (arch == "i386")
+    Indent(indent + kExtraIndent) << "'ARCHS': [ 'i386' ],\n";
+  else if (arch == "x86_64")
+    Indent(indent + kExtraIndent) << "'ARCHS': [ 'x86_64' ],\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);
     out_ << " ],\n";
   }
   if (!flags.cflags.empty() || !flags.cflags_cc.empty() ||
@@ skipping 218 matching lines @@
     return;
 
   EscapeOptions options;
   options.mode = ESCAPE_JSON;
 
   Indent(indent) << "'" << name << "': [";
   WriteArrayValues(out_, values);
   out_ << " ],\n";
 }