Revise C++ coding style using clang-format

Run the `Utilities/Scripts/clang-format.bash` script to update
all our C++ code to a new style defined by `.clang-format`.
Use `clang-format` version 3.8.

* If you reached this commit for a line in `git blame`, re-run the blame
  operation starting at the parent of this commit to see older history
  for the content.

* See the parent commit for instructions to rebase a change across this
  style transition commit.

1 files changed, 1293 insertions, 1897 deletions

diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index 022b802..efc239e 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -34,29 +34,25 @@
 class cmXcodeVersionParser : public cmXMLParser
 {
 public:
-  cmXcodeVersionParser(): Version("1.5") {}
-  void StartElement(const std::string&, const char**)
-    {
-      this->Data = "";
-    }
+  cmXcodeVersionParser()
+    : Version("1.5")
+  {
+  }
+  void StartElement(const std::string&, const char**) { this->Data = ""; }
   void EndElement(const std::string& name)
-    {
-      if(name == "key")
-        {
-        this->Key = this->Data;
-        }
-      else if(name == "string")
-        {
-        if(this->Key == "CFBundleShortVersionString")
-          {
-          this->Version = this->Data;
-          }
-        }
+  {
+    if (name == "key") {
+      this->Key = this->Data;
+    } else if (name == "string") {
+      if (this->Key == "CFBundleShortVersionString") {
+        this->Version = this->Data;
+      }
     }
+  }
   void CharacterDataHandler(const char* data, int length)
-    {
-      this->Data.append(data, length);
-    }
+  {
+    this->Data.append(data, length);
+  }
   std::string Version;
   std::string Key;
   std::string Data;
@@ -67,64 +63,63 @@ public:
 // given inputs.
 class cmGlobalXCodeGenerator::BuildObjectListOrString
 {
-  cmGlobalXCodeGenerator *Generator;
-  cmXCodeObject *Group;
+  cmGlobalXCodeGenerator* Generator;
+  cmXCodeObject* Group;
   bool Empty;
   std::string String;
 
 public:
-  BuildObjectListOrString(cmGlobalXCodeGenerator *gen, bool buildObjectList)
-    : Generator(gen), Group(0), Empty(true)
-    {
-    if (buildObjectList)
-      {
+  BuildObjectListOrString(cmGlobalXCodeGenerator* gen, bool buildObjectList)
+    : Generator(gen)
+    , Group(0)
+    , Empty(true)
+  {
+    if (buildObjectList) {
       this->Group = this->Generator->CreateObject(cmXCodeObject::OBJECT_LIST);
-      }
     }
+  }
 
   bool IsEmpty() const { return this->Empty; }
 
   void Add(const std::string& newString)
-    {
+  {
     this->Empty = false;
 
-    if (this->Group)
-      {
+    if (this->Group) {
       this->Group->AddObject(this->Generator->CreateString(newString));
-      }
-    else
-      {
+    } else {
       this->String += newString;
       this->String += ' ';
-      }
     }
+  }
 
-  const std::string &GetString() const { return this->String; }
+  const std::string& GetString() const { return this->String; }
 
-  cmXCodeObject *CreateList()
-    {
-    if (this->Group)
-      {
+  cmXCodeObject* CreateList()
+  {
+    if (this->Group) {
       return this->Group;
-      }
-    else
-      {
+    } else {
       return this->Generator->CreateString(this->String);
-      }
     }
+  }
 };
 
 class cmGlobalXCodeGenerator::Factory : public cmGlobalGeneratorFactory
 {
 public:
-  virtual cmGlobalGenerator*
-  CreateGlobalGenerator(const std::string& name, cmake* cm) const;
+  virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
+                                                   cmake* cm) const;
 
-  virtual void GetDocumentation(cmDocumentationEntry& entry) const {
-    cmGlobalXCodeGenerator::GetDocumentation(entry); }
+  virtual void GetDocumentation(cmDocumentationEntry& entry) const
+  {
+    cmGlobalXCodeGenerator::GetDocumentation(entry);
+  }
 
-  virtual void GetGenerators(std::vector<std::string>& names) const {
-    names.push_back(cmGlobalXCodeGenerator::GetActualName()); }
+  virtual void GetGenerators(std::vector<std::string>& names) const
+  {
+    names.push_back(cmGlobalXCodeGenerator::GetActualName());
+  }
 
   virtual bool SupportsToolset() const { return true; }
 };
@@ -136,9 +131,9 @@ cmGlobalXCodeGenerator::cmGlobalXCodeGenerator(cmake* cm,
   this->VersionString = version;
 
   // Compute an integer form of the version number.
-  unsigned int v[2] = {0,0};
+  unsigned int v[2] = { 0, 0 };
   sscanf(this->VersionString.c_str(), "%u.%u", &v[0], &v[1]);
-  this->XcodeVersion = 10*v[0] + v[1];
+  this->XcodeVersion = 10 * v[0] + v[1];
 
   this->RootObject = 0;
   this->MainGroupChildren = 0;
@@ -154,8 +149,8 @@ cmGlobalGeneratorFactory* cmGlobalXCodeGenerator::NewFactory()
   return new Factory;
 }
 
-cmGlobalGenerator* cmGlobalXCodeGenerator::Factory
-::CreateGlobalGenerator(const std::string& name, cmake* cm) const
+cmGlobalGenerator* cmGlobalXCodeGenerator::Factory::CreateGlobalGenerator(
+  const std::string& name, cmake* cm) const
 {
   if (name != GetActualName())
     return 0;
@@ -163,42 +158,34 @@ cmGlobalGenerator* cmGlobalXCodeGenerator::Factory
   cmXcodeVersionParser parser;
   std::string versionFile;
   {
-  std::string out;
-  std::string::size_type pos;
-  if(cmSystemTools::RunSingleCommand("xcode-select --print-path", &out, 0,
-                                     0, 0, cmSystemTools::OUTPUT_NONE) &&
-     (pos = out.find(".app/"), pos != out.npos))
-    {
-    versionFile = out.substr(0, pos+5)+"Contents/version.plist";
+    std::string out;
+    std::string::size_type pos;
+    if (cmSystemTools::RunSingleCommand("xcode-select --print-path", &out, 0,
+                                        0, 0, cmSystemTools::OUTPUT_NONE) &&
+        (pos = out.find(".app/"), pos != out.npos)) {
+      versionFile = out.substr(0, pos + 5) + "Contents/version.plist";
     }
   }
-  if(!versionFile.empty() && cmSystemTools::FileExists(versionFile.c_str()))
-    {
+  if (!versionFile.empty() && cmSystemTools::FileExists(versionFile.c_str())) {
     parser.ParseFile(versionFile.c_str());
-    }
-  else if (cmSystemTools::FileExists(
-             "/Applications/Xcode.app/Contents/version.plist"))
-    {
-    parser.ParseFile
-      ("/Applications/Xcode.app/Contents/version.plist");
-    }
-  else
-    {
-    parser.ParseFile
-      ("/Developer/Applications/Xcode.app/Contents/version.plist");
-    }
-  cmsys::auto_ptr<cmGlobalXCodeGenerator>
-    gg(new cmGlobalXCodeGenerator(cm, parser.Version));
-  if (gg->XcodeVersion == 20)
-    {
+  } else if (cmSystemTools::FileExists(
+               "/Applications/Xcode.app/Contents/version.plist")) {
+    parser.ParseFile("/Applications/Xcode.app/Contents/version.plist");
+  } else {
+    parser.ParseFile(
+      "/Developer/Applications/Xcode.app/Contents/version.plist");
+  }
+  cmsys::auto_ptr<cmGlobalXCodeGenerator> gg(
+    new cmGlobalXCodeGenerator(cm, parser.Version));
+  if (gg->XcodeVersion == 20) {
     cmSystemTools::Message("Xcode 2.0 not really supported by cmake, "
                            "using Xcode 15 generator\n");
     gg->XcodeVersion = 15;
-    }
+  }
   return gg.release();
 #else
   std::cerr << "CMake should be built with cmake to use Xcode, "
-    "default to Xcode 1.5\n";
+               "default to Xcode 1.5\n";
   return new cmGlobalXCodeGenerator(cm);
 #endif
 }
@@ -208,162 +195,125 @@ void cmGlobalXCodeGenerator::FindMakeProgram(cmMakefile* mf)
   // The Xcode generator knows how to lookup its build tool
   // directly instead of needing a helper module to do it, so we
   // do not actually need to put CMAKE_MAKE_PROGRAM into the cache.
-  if(cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM")))
-    {
+  if (cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) {
     mf->AddDefinition("CMAKE_MAKE_PROGRAM",
                       this->GetXcodeBuildCommand().c_str());
-    }
+  }
 }
 
 std::string const& cmGlobalXCodeGenerator::GetXcodeBuildCommand()
 {
-  if(!this->XcodeBuildCommandInitialized)
-    {
+  if (!this->XcodeBuildCommandInitialized) {
     this->XcodeBuildCommandInitialized = true;
     this->XcodeBuildCommand = this->FindXcodeBuildCommand();
-    }
+  }
   return this->XcodeBuildCommand;
 }
 
 std::string cmGlobalXCodeGenerator::FindXcodeBuildCommand()
 {
-  if (this->XcodeVersion >= 40)
-    {
+  if (this->XcodeVersion >= 40) {
     std::string makeProgram = cmSystemTools::FindProgram("xcodebuild");
-    if (makeProgram.empty())
-      {
+    if (makeProgram.empty()) {
       makeProgram = "xcodebuild";
-      }
-    return makeProgram;
     }
-  else
-    {
+    return makeProgram;
+  } else {
     // Use cmakexbuild wrapper to suppress environment dump from output.
     return cmSystemTools::GetCMakeCommand() + "xbuild";
-    }
+  }
 }
 
 bool cmGlobalXCodeGenerator::SetGeneratorToolset(std::string const& ts,
                                                  cmMakefile* mf)
 {
-  if(this->XcodeVersion >= 30)
-    {
+  if (this->XcodeVersion >= 30) {
     this->GeneratorToolset = ts;
-    if(!this->GeneratorToolset.empty())
-      {
+    if (!this->GeneratorToolset.empty()) {
       mf->AddDefinition("CMAKE_XCODE_PLATFORM_TOOLSET",
                         this->GeneratorToolset.c_str());
-      }
-    return true;
     }
-  else
-    {
+    return true;
+  } else {
     return cmGlobalGenerator::SetGeneratorToolset(ts, mf);
-    }
+  }
 }
 
-void cmGlobalXCodeGenerator::EnableLanguage(std::vector<std::string>const&
-                                            lang,
-                                            cmMakefile * mf, bool optional)
+void cmGlobalXCodeGenerator::EnableLanguage(
+  std::vector<std::string> const& lang, cmMakefile* mf, bool optional)
 {
-  mf->AddDefinition("XCODE","1");
+  mf->AddDefinition("XCODE", "1");
   mf->AddDefinition("XCODE_VERSION", this->VersionString.c_str());
-  if(this->XcodeVersion == 15)
-    {
-    }
-  else
-    {
-    if(!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
-      {
+  if (this->XcodeVersion == 15) {
+  } else {
+    if (!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES")) {
       mf->AddCacheDefinition(
-        "CMAKE_CONFIGURATION_TYPES",
-        "Debug;Release;MinSizeRel;RelWithDebInfo",
+        "CMAKE_CONFIGURATION_TYPES", "Debug;Release;MinSizeRel;RelWithDebInfo",
         "Semicolon separated list of supported configuration types, "
         "only supports Debug, Release, MinSizeRel, and RelWithDebInfo, "
         "anything else will be ignored.",
         cmState::STRING);
-      }
     }
+  }
   mf->AddDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV", "1");
   this->cmGlobalGenerator::EnableLanguage(lang, mf, optional);
-    const char* osxArch =
-      mf->GetDefinition("CMAKE_OSX_ARCHITECTURES");
-  const char* sysroot =
-      mf->GetDefinition("CMAKE_OSX_SYSROOT");
-  if(osxArch && sysroot)
-    {
+  const char* osxArch = mf->GetDefinition("CMAKE_OSX_ARCHITECTURES");
+  const char* sysroot = mf->GetDefinition("CMAKE_OSX_SYSROOT");
+  if (osxArch && sysroot) {
     this->Architectures.clear();
     cmSystemTools::ExpandListArgument(std::string(osxArch),
                                       this->Architectures);
-    }
+  }
 }
 
-void
-cmGlobalXCodeGenerator::GenerateBuildCommand(
-  std::vector<std::string>& makeCommand,
-  const std::string& makeProgram,
-  const std::string& projectName,
-  const std::string& /*projectDir*/,
-  const std::string& targetName,
-  const std::string& config,
-  bool /*fast*/, bool /*verbose*/,
-  std::vector<std::string> const& makeOptions)
+void cmGlobalXCodeGenerator::GenerateBuildCommand(
+  std::vector<std::string>& makeCommand, const std::string& makeProgram,
+  const std::string& projectName, const std::string& /*projectDir*/,
+  const std::string& targetName, const std::string& config, bool /*fast*/,
+  bool /*verbose*/, std::vector<std::string> const& makeOptions)
 {
   // now build the test
   makeCommand.push_back(
-    this->SelectMakeProgram(makeProgram, this->GetXcodeBuildCommand())
-    );
+    this->SelectMakeProgram(makeProgram, this->GetXcodeBuildCommand()));
 
   makeCommand.push_back("-project");
   std::string projectArg = projectName;
   projectArg += ".xcode";
-  if(this->XcodeVersion > 20)
-    {
+  if (this->XcodeVersion > 20) {
     projectArg += "proj";
-    }
+  }
   makeCommand.push_back(projectArg);
 
   bool clean = false;
   std::string realTarget = targetName;
-  if ( realTarget == "clean" )
-    {
+  if (realTarget == "clean") {
     clean = true;
     realTarget = "ALL_BUILD";
-    }
-  if(clean)
-    {
+  }
+  if (clean) {
     makeCommand.push_back("clean");
-    }
-  else
-    {
+  } else {
     makeCommand.push_back("build");
-    }
+  }
   makeCommand.push_back("-target");
-  if (!realTarget.empty())
-    {
+  if (!realTarget.empty()) {
     makeCommand.push_back(realTarget);
-    }
-  else
-    {
+  } else {
     makeCommand.push_back("ALL_BUILD");
-    }
-  if(this->XcodeVersion == 15)
-    {
+  }
+  if (this->XcodeVersion == 15) {
     makeCommand.push_back("-buildstyle");
     makeCommand.push_back("Development");
-    }
-  else
-    {
+  } else {
     makeCommand.push_back("-configuration");
-    makeCommand.push_back(!config.empty()?config:"Debug");
-    }
-  makeCommand.insert(makeCommand.end(),
-                     makeOptions.begin(), makeOptions.end());
+    makeCommand.push_back(!config.empty() ? config : "Debug");
+  }
+  makeCommand.insert(makeCommand.end(), makeOptions.begin(),
+                     makeOptions.end());
 }
 
 ///! Create a local generator appropriate to this Global Generator
-cmLocalGenerator *
-cmGlobalXCodeGenerator::CreateLocalGenerator(cmMakefile* mf)
+cmLocalGenerator* cmGlobalXCodeGenerator::CreateLocalGenerator(cmMakefile* mf)
 {
   return new cmLocalXCodeGenerator(this, mf);
 }
@@ -373,30 +323,27 @@ void cmGlobalXCodeGenerator::AddExtraIDETargets()
   std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
   // make sure extra targets are added before calling
   // the parent generate which will call trace depends
-  for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
-    {
+  for (it = this->ProjectMap.begin(); it != this->ProjectMap.end(); ++it) {
     cmLocalGenerator* root = it->second[0];
     this->SetGenerationRoot(root);
     // add ALL_BUILD, INSTALL, etc
     this->AddExtraTargets(root, it->second);
-    }
+  }
 }
 
 void cmGlobalXCodeGenerator::Generate()
 {
   this->cmGlobalGenerator::Generate();
-  if(cmSystemTools::GetErrorOccuredFlag())
-    {
+  if (cmSystemTools::GetErrorOccuredFlag()) {
     return;
-    }
+  }
   std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
-  for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
-    {
+  for (it = this->ProjectMap.begin(); it != this->ProjectMap.end(); ++it) {
     cmLocalGenerator* root = it->second[0];
     this->SetGenerationRoot(root);
     // now create the project
     this->OutputXCodeProject(root, it->second);
-    }
+  }
 }
 
 void cmGlobalXCodeGenerator::SetGenerationRoot(cmLocalGenerator* root)
@@ -404,47 +351,43 @@ void cmGlobalXCodeGenerator::SetGenerationRoot(cmLocalGenerator* root)
   this->CurrentProject = root->GetProjectName();
   this->SetCurrentLocalGenerator(root);
   cmSystemTools::SplitPath(
-        this->CurrentLocalGenerator->GetCurrentSourceDirectory(),
-        this->ProjectSourceDirectoryComponents);
+    this->CurrentLocalGenerator->GetCurrentSourceDirectory(),
+    this->ProjectSourceDirectoryComponents);
   cmSystemTools::SplitPath(
-        this->CurrentLocalGenerator->GetCurrentBinaryDirectory(),
-        this->ProjectOutputDirectoryComponents);
+    this->CurrentLocalGenerator->GetCurrentBinaryDirectory(),
+    this->ProjectOutputDirectoryComponents);
 
-  this->CurrentXCodeHackMakefile =
-    root->GetCurrentBinaryDirectory();
+  this->CurrentXCodeHackMakefile = root->GetCurrentBinaryDirectory();
   this->CurrentXCodeHackMakefile += "/CMakeScripts";
   cmSystemTools::MakeDirectory(this->CurrentXCodeHackMakefile.c_str());
   this->CurrentXCodeHackMakefile += "/XCODE_DEPEND_HELPER.make";
 }
 
-std::string
-cmGlobalXCodeGenerator::PostBuildMakeTarget(std::string const& tName,
-                                            std::string const& configName)
+std::string cmGlobalXCodeGenerator::PostBuildMakeTarget(
+  std::string const& tName, std::string const& configName)
 {
   std::string target = tName;
   cmSystemTools::ReplaceString(target, " ", "_");
   std::string out = "PostBuild." + target;
-  if(this->XcodeVersion > 20)
-    {
+  if (this->XcodeVersion > 20) {
     out += "." + configName;
-    }
+  }
   return out;
 }
 
 #define CMAKE_CHECK_BUILD_SYSTEM_TARGET "ZERO_CHECK"
 
-void
-cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
-                                        std::vector<cmLocalGenerator*>& gens)
+void cmGlobalXCodeGenerator::AddExtraTargets(
+  cmLocalGenerator* root, std::vector<cmLocalGenerator*>& gens)
 {
   cmMakefile* mf = root->GetMakefile();
 
   // Add ALL_BUILD
   const char* no_working_directory = 0;
   std::vector<std::string> no_depends;
-  cmTarget* allbuild = mf->AddUtilityCommand("ALL_BUILD", true, no_depends,
-                        no_working_directory,
-                        "echo", "Build all projects");
+  cmTarget* allbuild =
+    mf->AddUtilityCommand("ALL_BUILD", true, no_depends, no_working_directory,
+                          "echo", "Build all projects");
 
   cmGeneratorTarget* allBuildGt = new cmGeneratorTarget(allbuild, root);
   root->AddGeneratorTarget(allBuildGt);
@@ -458,113 +401,98 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
   // Add XCODE depend helper
   std::string dir = root->GetCurrentBinaryDirectory();
   cmCustomCommandLine makeHelper;
-  if(this->XcodeVersion < 50)
-    {
+  if (this->XcodeVersion < 50) {
     makeHelper.push_back("make");
     makeHelper.push_back("-C");
     makeHelper.push_back(dir.c_str());
     makeHelper.push_back("-f");
     makeHelper.push_back(this->CurrentXCodeHackMakefile.c_str());
     makeHelper.push_back(""); // placeholder, see below
-    }
+  }
 
   // Add ZERO_CHECK
   bool regenerate = !mf->IsOn("CMAKE_SUPPRESS_REGENERATION");
-  if (regenerate)
-    {
+  if (regenerate) {
     this->CreateReRunCMakeFile(root, gens);
-    std::string file = this->ConvertToRelativeForMake(
-      this->CurrentReRunCMakeMakefile.c_str());
+    std::string file =
+      this->ConvertToRelativeForMake(this->CurrentReRunCMakeMakefile.c_str());
     cmSystemTools::ReplaceString(file, "\\ ", " ");
-    cmTarget* check = mf->AddUtilityCommand(CMAKE_CHECK_BUILD_SYSTEM_TARGET,
-                          true, no_depends,
-                          no_working_directory,
-                          "make", "-f", file.c_str());
+    cmTarget* check =
+      mf->AddUtilityCommand(CMAKE_CHECK_BUILD_SYSTEM_TARGET, true, no_depends,
+                            no_working_directory, "make", "-f", file.c_str());
 
     cmGeneratorTarget* checkGt = new cmGeneratorTarget(check, root);
     root->AddGeneratorTarget(checkGt);
-    }
+  }
 
   // now make the allbuild depend on all the non-utility targets
   // in the project
-  for(std::vector<cmLocalGenerator*>::iterator i = gens.begin();
-      i != gens.end(); ++i)
-    {
+  for (std::vector<cmLocalGenerator*>::iterator i = gens.begin();
+       i != gens.end(); ++i) {
     cmLocalGenerator* lg = *i;
-    if(this->IsExcluded(root, *i))
-      {
+    if (this->IsExcluded(root, *i)) {
       continue;
-      }
+    }
 
     std::vector<cmGeneratorTarget*> tgts = lg->GetGeneratorTargets();
-    for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-        l != tgts.end(); l++)
-      {
+    for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
+         l != tgts.end(); l++) {
       cmGeneratorTarget* target = *l;
 
-      if (target->GetType() == cmState::GLOBAL_TARGET)
-        {
+      if (target->GetType() == cmState::GLOBAL_TARGET) {
         continue;
-        }
+      }
 
       std::string targetName = target->GetName();
 
-      if (regenerate && (targetName != CMAKE_CHECK_BUILD_SYSTEM_TARGET))
-        {
+      if (regenerate && (targetName != CMAKE_CHECK_BUILD_SYSTEM_TARGET)) {
         target->Target->AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET);
-        }
+      }
 
       // make all exe, shared libs and modules
       // run the depend check makefile as a post build rule
       // this will make sure that when the next target is built
       // things are up-to-date
-      if(!makeHelper.empty() &&
-         (target->GetType() == cmState::EXECUTABLE ||
-// Nope - no post-build for OBJECT_LIRBRARY
-//          target->GetType() == cmState::OBJECT_LIBRARY ||
-          target->GetType() == cmState::STATIC_LIBRARY ||
-          target->GetType() == cmState::SHARED_LIBRARY ||
-          target->GetType() == cmState::MODULE_LIBRARY))
-        {
-        makeHelper[makeHelper.size()-1] = // fill placeholder
+      if (!makeHelper.empty() &&
+          (target->GetType() == cmState::EXECUTABLE ||
+           // Nope - no post-build for OBJECT_LIRBRARY
+           //          target->GetType() == cmState::OBJECT_LIBRARY ||
+           target->GetType() == cmState::STATIC_LIBRARY ||
+           target->GetType() == cmState::SHARED_LIBRARY ||
+           target->GetType() == cmState::MODULE_LIBRARY)) {
+        makeHelper[makeHelper.size() - 1] = // fill placeholder
           this->PostBuildMakeTarget(target->GetName(), "$(CONFIGURATION)");
         cmCustomCommandLines commandLines;
         commandLines.push_back(makeHelper);
         std::vector<std::string> no_byproducts;
-        lg->GetMakefile()->AddCustomCommandToTarget(target->GetName(),
-                                                    no_byproducts,
-                                                    no_depends,
-                                                    commandLines,
-                                                    cmTarget::POST_BUILD,
-                                                    "Depend check for xcode",
-                                                    dir.c_str());
-        }
+        lg->GetMakefile()->AddCustomCommandToTarget(
+          target->GetName(), no_byproducts, no_depends, commandLines,
+          cmTarget::POST_BUILD, "Depend check for xcode", dir.c_str());
+      }
 
-      if(target->GetType() != cmState::INTERFACE_LIBRARY
-          && !target->GetPropertyAsBool("EXCLUDE_FROM_ALL"))
-        {
+      if (target->GetType() != cmState::INTERFACE_LIBRARY &&
+          !target->GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
         allbuild->AddUtility(target->GetName());
-        }
+      }
 
       // Refer to the build configuration file for easy editing.
       listfile = lg->GetCurrentSourceDirectory();
       listfile += "/";
       listfile += "CMakeLists.txt";
       target->AddSource(listfile.c_str());
-      }
     }
+  }
 }
 
 void cmGlobalXCodeGenerator::CreateReRunCMakeFile(
   cmLocalGenerator* root, std::vector<cmLocalGenerator*> const& gens)
 {
   std::vector<std::string> lfiles;
-  for(std::vector<cmLocalGenerator*>::const_iterator gi = gens.begin();
-      gi != gens.end(); ++gi)
-    {
+  for (std::vector<cmLocalGenerator*>::const_iterator gi = gens.begin();
+       gi != gens.end(); ++gi) {
     std::vector<std::string> const& lf = (*gi)->GetMakefile()->GetListFiles();
     lfiles.insert(lfiles.end(), lf.begin(), lf.end());
-    }
+  }
 
   // sort the array
   std::sort(lfiles.begin(), lfiles.end(), std::less<std::string>());
@@ -575,8 +503,8 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile(
   this->CurrentReRunCMakeMakefile += "/CMakeScripts";
   cmSystemTools::MakeDirectory(this->CurrentReRunCMakeMakefile.c_str());
   this->CurrentReRunCMakeMakefile += "/ReRunCMake.make";
-  cmGeneratedFileStream makefileStream
-    (this->CurrentReRunCMakeMakefile.c_str());
+  cmGeneratedFileStream makefileStream(
+    this->CurrentReRunCMakeMakefile.c_str());
   makefileStream.SetCopyIfDifferent(true);
   makefileStream << "# Generated by CMake, DO NOT EDIT\n\n";
 
@@ -584,30 +512,30 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile(
   makefileStream << "space:= $(empty) $(empty)\n";
   makefileStream << "spaceplus:= $(empty)\\ $(empty)\n\n";
 
-  for(std::vector<std::string>::const_iterator i = lfiles.begin();
-      i !=  lfiles.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = lfiles.begin();
+       i != lfiles.end(); ++i) {
     makefileStream << "TARGETS += $(subst $(space),$(spaceplus),$(wildcard "
-                   << this->ConvertToRelativeForMake(i->c_str())
-                   << "))\n";
-    }
+                   << this->ConvertToRelativeForMake(i->c_str()) << "))\n";
+  }
 
   std::string checkCache = root->GetBinaryDirectory();
   checkCache += "/";
   checkCache += cmake::GetCMakeFilesDirectoryPostSlash();
   checkCache += "cmake.check_cache";
 
-  makefileStream << "\n" << this->ConvertToRelativeForMake(checkCache.c_str())
+  makefileStream << "\n"
+                 << this->ConvertToRelativeForMake(checkCache.c_str())
                  << ": $(TARGETS)\n";
-  makefileStream << "\t" <<
-    this->ConvertToRelativeForMake(cmSystemTools::GetCMakeCommand().c_str())
-                 << " -H" << this->ConvertToRelativeForMake(
-                   root->GetSourceDirectory())
-                 << " -B" << this->ConvertToRelativeForMake(
-                   root->GetBinaryDirectory()) << "\n";
+  makefileStream << "\t"
+                 << this->ConvertToRelativeForMake(
+                      cmSystemTools::GetCMakeCommand().c_str())
+                 << " -H"
+                 << this->ConvertToRelativeForMake(root->GetSourceDirectory())
+                 << " -B"
+                 << this->ConvertToRelativeForMake(root->GetBinaryDirectory())
+                 << "\n";
 }
 
-
 static bool objectIdLessThan(cmXCodeObject* l, cmXCodeObject* r)
 {
   return l->GetId() < r->GetId();
@@ -622,10 +550,9 @@ void cmGlobalXCodeGenerator::SortXCodeObjects()
 void cmGlobalXCodeGenerator::ClearXCodeObjects()
 {
   this->TargetDoneSet.clear();
-  for(unsigned int i = 0; i < this->XCodeObjects.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->XCodeObjects.size(); ++i) {
     delete this->XCodeObjects[i];
-    }
+  }
   this->XCodeObjects.clear();
   this->XCodeObjectIDs.clear();
   this->XCodeObjectMap.clear();
@@ -635,76 +562,68 @@ void cmGlobalXCodeGenerator::ClearXCodeObjects()
   this->FileRefs.clear();
 }
 
-void cmGlobalXCodeGenerator::addObject(cmXCodeObject *obj)
+void cmGlobalXCodeGenerator::addObject(cmXCodeObject* obj)
 {
-  if(obj->GetType() == cmXCodeObject::OBJECT)
-    {
+  if (obj->GetType() == cmXCodeObject::OBJECT) {
     std::string id = obj->GetId();
 
     // If this is a duplicate id, it's an error:
     //
-    if(this->XCodeObjectIDs.count(id))
-      {
+    if (this->XCodeObjectIDs.count(id)) {
       cmSystemTools::Error(
         "Xcode generator: duplicate object ids not allowed");
-      }
+    }
 
     this->XCodeObjectIDs.insert(id);
-    }
+  }
 
   this->XCodeObjects.push_back(obj);
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::PBXType ptype)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateObject(
+  cmXCodeObject::PBXType ptype)
 {
   cmXCodeObject* obj;
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     obj = new cmXCodeObject(ptype, cmXCodeObject::OBJECT);
-    }
-  else
-    {
+  } else {
     obj = new cmXCode21Object(ptype, cmXCodeObject::OBJECT);
-    }
+  }
   this->addObject(obj);
   return obj;
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::Type type)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::Type type)
 {
   cmXCodeObject* obj = new cmXCodeObject(cmXCodeObject::None, type);
   this->addObject(obj);
   return obj;
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateString(const std::string& s)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateString(const std::string& s)
 {
   cmXCodeObject* obj = this->CreateObject(cmXCodeObject::STRING);
   obj->SetString(s);
   return obj;
 }
 
-cmXCodeObject* cmGlobalXCodeGenerator
-::CreateObjectReference(cmXCodeObject* ref)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateObjectReference(
+  cmXCodeObject* ref)
 {
   cmXCodeObject* obj = this->CreateObject(cmXCodeObject::OBJECT_REF);
   obj->SetObject(ref);
   return obj;
 }
 
-cmXCodeObject* cmGlobalXCodeGenerator
-::CreateFlatClone(cmXCodeObject* orig)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateFlatClone(cmXCodeObject* orig)
 {
   cmXCodeObject* obj = this->CreateObject(orig->GetType());
   obj->CopyAttributes(orig);
   return obj;
 }
 
-std::string
-GetGroupMapKeyFromPath(cmGeneratorTarget* target, const std::string& fullpath)
+std::string GetGroupMapKeyFromPath(cmGeneratorTarget* target,
+                                   const std::string& fullpath)
 {
   std::string key(target->GetName());
   key += "-";
@@ -712,18 +631,14 @@ GetGroupMapKeyFromPath(cmGeneratorTarget* target, const std::string& fullpath)
   return key;
 }
 
-std::string
-GetGroupMapKey(cmGeneratorTarget* target, cmSourceFile* sf)
+std::string GetGroupMapKey(cmGeneratorTarget* target, cmSourceFile* sf)
 {
   return GetGroupMapKeyFromPath(target, sf->GetFullPath());
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath(
-  const std::string &fullpath,
-  cmGeneratorTarget* target,
-  const std::string &lang,
-  cmSourceFile* sf)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath(
+  const std::string& fullpath, cmGeneratorTarget* target,
+  const std::string& lang, cmSourceFile* sf)
 {
   // Using a map and the full path guarantees that we will always get the same
   // fileRef object for any given full path.
@@ -738,168 +653,127 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath(
   return buildFile;
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg,
-                                              cmSourceFile* sf,
-                                              cmGeneratorTarget* gtgt)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeSourceFile(
+  cmLocalGenerator* lg, cmSourceFile* sf, cmGeneratorTarget* gtgt)
 {
   // Add flags from target and source file properties.
   std::string flags;
   const char* srcfmt = sf->GetProperty("Fortran_FORMAT");
-  switch(this->CurrentLocalGenerator->GetFortranFormat(srcfmt))
-    {
-    case cmLocalGenerator::FortranFormatFixed: flags="-fixed "+flags; break;
-    case cmLocalGenerator::FortranFormatFree: flags="-free "+flags; break;
-    default: break;
-    }
+  switch (this->CurrentLocalGenerator->GetFortranFormat(srcfmt)) {
+    case cmLocalGenerator::FortranFormatFixed:
+      flags = "-fixed " + flags;
+      break;
+    case cmLocalGenerator::FortranFormatFree:
+      flags = "-free " + flags;
+      break;
+    default:
+      break;
+  }
   lg->AppendFlags(flags, sf->GetProperty("COMPILE_FLAGS"));
 
   // Add per-source definitions.
   BuildObjectListOrString flagsBuild(this, false);
-  this->AppendDefines(flagsBuild,
-                      sf->GetProperty("COMPILE_DEFINITIONS"), true);
-  if (!flagsBuild.IsEmpty())
-    {
-    if (!flags.empty())
-      {
+  this->AppendDefines(flagsBuild, sf->GetProperty("COMPILE_DEFINITIONS"),
+                      true);
+  if (!flagsBuild.IsEmpty()) {
+    if (!flags.empty()) {
       flags += ' ';
-      }
-    flags += flagsBuild.GetString();
     }
+    flags += flagsBuild.GetString();
+  }
 
-  std::string lang =
-    this->CurrentLocalGenerator->GetSourceFileLanguage(*sf);
+  std::string lang = this->CurrentLocalGenerator->GetSourceFileLanguage(*sf);
 
   cmXCodeObject* buildFile =
     this->CreateXCodeSourceFileFromPath(sf->GetFullPath(), gtgt, lang, sf);
   cmXCodeObject* fileRef = buildFile->GetObject("fileRef")->GetObject();
 
-  cmXCodeObject* settings =
-    this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
+  cmXCodeObject* settings = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
   settings->AddAttribute("COMPILER_FLAGS", this->CreateString(flags));
 
   // Is this a resource file in this target? Add it to the resources group...
   //
 
   cmGeneratorTarget::SourceFileFlags tsFlags =
-      gtgt->GetTargetSourceFileFlags(sf);
+    gtgt->GetTargetSourceFileFlags(sf);
   bool isResource = tsFlags.Type == cmGeneratorTarget::SourceFileTypeResource;
 
   // Is this a "private" or "public" framework header file?
   // Set the ATTRIBUTES attribute appropriately...
   //
-  if(gtgt->IsFrameworkOnApple())
-    {
-    if(tsFlags.Type == cmGeneratorTarget::SourceFileTypePrivateHeader)
-      {
+  if (gtgt->IsFrameworkOnApple()) {
+    if (tsFlags.Type == cmGeneratorTarget::SourceFileTypePrivateHeader) {
       cmXCodeObject* attrs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
       attrs->AddObject(this->CreateString("Private"));
       settings->AddAttribute("ATTRIBUTES", attrs);
       isResource = true;
-      }
-    else if(tsFlags.Type == cmGeneratorTarget::SourceFileTypePublicHeader)
-      {
+    } else if (tsFlags.Type == cmGeneratorTarget::SourceFileTypePublicHeader) {
       cmXCodeObject* attrs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
       attrs->AddObject(this->CreateString("Public"));
       settings->AddAttribute("ATTRIBUTES", attrs);
       isResource = true;
-      }
     }
+  }
 
   // Add the fileRef to the top level Resources group/folder if it is not
   // already there.
   //
-  if(isResource && this->ResourcesGroupChildren &&
-    !this->ResourcesGroupChildren->HasObject(fileRef))
-    {
+  if (isResource && this->ResourcesGroupChildren &&
+      !this->ResourcesGroupChildren->HasObject(fileRef)) {
     this->ResourcesGroupChildren->AddObject(fileRef);
-    }
+  }
 
   buildFile->AddAttribute("settings", settings);
   return buildFile;
 }
 
-std::string
-GetSourcecodeValueFromFileExtension(const std::string& _ext,
-                                    const std::string& lang,
-                                    bool& keepLastKnownFileType)
+std::string GetSourcecodeValueFromFileExtension(const std::string& _ext,
+                                                const std::string& lang,
+                                                bool& keepLastKnownFileType)
 {
   std::string ext = cmSystemTools::LowerCase(_ext);
   std::string sourcecode = "sourcecode";
 
-  if(ext == "o")
-    {
+  if (ext == "o") {
     sourcecode = "compiled.mach-o.objfile";
-    }
-  else if(ext == "xctest")
-    {
+  } else if (ext == "xctest") {
     sourcecode = "wrapper.cfbundle";
-    }
-  else if(ext == "xib")
-    {
+  } else if (ext == "xib") {
     keepLastKnownFileType = true;
     sourcecode = "file.xib";
-    }
-  else if(ext == "storyboard")
-    {
+  } else if (ext == "storyboard") {
     keepLastKnownFileType = true;
     sourcecode = "file.storyboard";
-    }
-  else if(ext == "mm")
-    {
+  } else if (ext == "mm") {
     sourcecode += ".cpp.objcpp";
-    }
-  else if(ext == "m")
-    {
+  } else if (ext == "m") {
     sourcecode += ".c.objc";
-    }
-  else if (ext == "swift")
-    {
+  } else if (ext == "swift") {
     sourcecode += ".swift";
-    }
-  else if(ext == "plist")
-    {
+  } else if (ext == "plist") {
     sourcecode += ".text.plist";
-    }
-  else if(ext == "h")
-    {
+  } else if (ext == "h") {
     sourcecode += ".c.h";
-    }
-  else if(ext == "hxx" || ext == "hpp" || ext == "txx"
-    || ext == "pch" || ext == "hh")
-    {
+  } else if (ext == "hxx" || ext == "hpp" || ext == "txx" || ext == "pch" ||
+             ext == "hh") {
     sourcecode += ".cpp.h";
-    }
-  else if(ext == "png" || ext == "gif" || ext == "jpg")
-    {
+  } else if (ext == "png" || ext == "gif" || ext == "jpg") {
     keepLastKnownFileType = true;
     sourcecode = "image";
-    }
-  else if(ext == "txt")
-    {
+  } else if (ext == "txt") {
     sourcecode += ".text";
-    }
-  else if(lang == "CXX")
-    {
+  } else if (lang == "CXX") {
     sourcecode += ".cpp.cpp";
-    }
-  else if(lang == "C")
-    {
+  } else if (lang == "C") {
     sourcecode += ".c.c";
-    }
-  else if(lang == "Fortran")
-    {
+  } else if (lang == "Fortran") {
     sourcecode += ".fortran.f90";
-    }
-  else if(lang == "ASM")
-    {
+  } else if (lang == "ASM") {
     sourcecode += ".asm";
-    }
-  else if (ext == "metal")
-    {
+  } else if (ext == "metal") {
     sourcecode += ".metal";
-    }
-  //else
+  }
+  // else
   //  {
   //  // Already specialized above or we leave sourcecode == "sourcecode"
   //  // which is probably the most correct choice. Extensionless headers,
@@ -910,111 +784,93 @@ GetSourcecodeValueFromFileExtension(const std::string& _ext,
   return sourcecode;
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateXCodeFileReferenceFromPath(
-  const std::string &fullpath,
-  cmGeneratorTarget* target,
-  const std::string &lang,
-  cmSourceFile* sf)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeFileReferenceFromPath(
+  const std::string& fullpath, cmGeneratorTarget* target,
+  const std::string& lang, cmSourceFile* sf)
 {
   std::string key = GetGroupMapKeyFromPath(target, fullpath);
   cmXCodeObject* fileRef = this->FileRefs[key];
-  if(!fileRef)
-    {
+  if (!fileRef) {
     fileRef = this->CreateObject(cmXCodeObject::PBXFileReference);
     fileRef->SetComment(fullpath);
     this->FileRefs[key] = fileRef;
-    }
+  }
   cmXCodeObject* group = this->GroupMap[key];
   cmXCodeObject* children = group->GetObject("children");
-  if (!children->HasObject(fileRef))
-    {
+  if (!children->HasObject(fileRef)) {
     children->AddObject(fileRef);
-    }
+  }
   fileRef->AddAttribute("fileEncoding", this->CreateString("4"));
 
   bool useLastKnownFileType = false;
   std::string fileType;
-  if(sf)
-    {
-    if(const char* e = sf->GetProperty("XCODE_EXPLICIT_FILE_TYPE"))
-      {
+  if (sf) {
+    if (const char* e = sf->GetProperty("XCODE_EXPLICIT_FILE_TYPE")) {
       fileType = e;
-      }
-    else if(const char* l = sf->GetProperty("XCODE_LAST_KNOWN_FILE_TYPE"))
-      {
+    } else if (const char* l = sf->GetProperty("XCODE_LAST_KNOWN_FILE_TYPE")) {
       useLastKnownFileType = true;
       fileType = l;
-      }
     }
-  if(fileType.empty())
-    {
+  }
+  if (fileType.empty()) {
     // Compute the extension without leading '.'.
     std::string ext = cmSystemTools::GetFilenameLastExtension(fullpath);
-    if(!ext.empty())
-      {
+    if (!ext.empty()) {
       ext = ext.substr(1);
-      }
+    }
 
     // If fullpath references a directory, then we need to specify
     // lastKnownFileType as folder in order for Xcode to be able to
     // open the contents of the folder.
     // (Xcode 4.6 does not like explicitFileType=folder).
-    if(cmSystemTools::FileIsDirectory(fullpath.c_str()))
-      {
-      fileType = (ext == "xcassets"? "folder.assetcatalog" : "folder");
+    if (cmSystemTools::FileIsDirectory(fullpath.c_str())) {
+      fileType = (ext == "xcassets" ? "folder.assetcatalog" : "folder");
       useLastKnownFileType = true;
-      }
-    else
-      {
-      fileType = GetSourcecodeValueFromFileExtension(
-        ext, lang, useLastKnownFileType);
-      }
+    } else {
+      fileType =
+        GetSourcecodeValueFromFileExtension(ext, lang, useLastKnownFileType);
     }
+  }
 
-  fileRef->AddAttribute(useLastKnownFileType? "lastKnownFileType"
-                                            : "explicitFileType",
+  fileRef->AddAttribute(useLastKnownFileType ? "lastKnownFileType"
+                                             : "explicitFileType",
                         this->CreateString(fileType));
 
   // Store the file path relative to the top of the source tree.
   std::string path = this->RelativeToSource(fullpath.c_str());
   std::string name = cmSystemTools::GetFilenameName(path.c_str());
-  const char* sourceTree = (cmSystemTools::FileIsFullPath(path.c_str())?
-                            "<absolute>" : "SOURCE_ROOT");
+  const char* sourceTree =
+    (cmSystemTools::FileIsFullPath(path.c_str()) ? "<absolute>"
+                                                 : "SOURCE_ROOT");
   fileRef->AddAttribute("name", this->CreateString(name));
   fileRef->AddAttribute("path", this->CreateString(path));
   fileRef->AddAttribute("sourceTree", this->CreateString(sourceTree));
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     fileRef->AddAttribute("refType", this->CreateString("4"));
-    }
+  }
   return fileRef;
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateXCodeFileReference(cmSourceFile* sf,
-                                                 cmGeneratorTarget* target)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeFileReference(
+  cmSourceFile* sf, cmGeneratorTarget* target)
 {
-  std::string lang =
-    this->CurrentLocalGenerator->GetSourceFileLanguage(*sf);
+  std::string lang = this->CurrentLocalGenerator->GetSourceFileLanguage(*sf);
 
-  return this->CreateXCodeFileReferenceFromPath(
-    sf->GetFullPath(), target, lang, sf);
+  return this->CreateXCodeFileReferenceFromPath(sf->GetFullPath(), target,
+                                                lang, sf);
 }
 
 bool cmGlobalXCodeGenerator::SpecialTargetEmitted(std::string const& tname)
 {
-  if(tname == "ALL_BUILD" || tname == "XCODE_DEPEND_HELPER" ||
-     tname == "install" || tname == "package" || tname == "RUN_TESTS" ||
-     tname == CMAKE_CHECK_BUILD_SYSTEM_TARGET )
-    {
-    if(this->TargetDoneSet.find(tname) != this->TargetDoneSet.end())
-      {
+  if (tname == "ALL_BUILD" || tname == "XCODE_DEPEND_HELPER" ||
+      tname == "install" || tname == "package" || tname == "RUN_TESTS" ||
+      tname == CMAKE_CHECK_BUILD_SYSTEM_TARGET) {
+    if (this->TargetDoneSet.find(tname) != this->TargetDoneSet.end()) {
       return true;
-      }
+    }
     this->TargetDoneSet.insert(tname);
     return false;
-    }
+  }
   return false;
 }
 
@@ -1022,19 +878,17 @@ void cmGlobalXCodeGenerator::SetCurrentLocalGenerator(cmLocalGenerator* gen)
 {
   this->CurrentLocalGenerator = gen;
   this->CurrentMakefile = gen->GetMakefile();
-  std::string outdir =
-    cmSystemTools::CollapseFullPath(this->CurrentLocalGenerator->
-                                    GetCurrentBinaryDirectory());
+  std::string outdir = cmSystemTools::CollapseFullPath(
+    this->CurrentLocalGenerator->GetCurrentBinaryDirectory());
   cmSystemTools::SplitPath(outdir.c_str(),
                            this->CurrentOutputDirectoryComponents);
 
   // Select the current set of configuration types.
   this->CurrentConfigurationTypes.clear();
   this->CurrentMakefile->GetConfigurations(this->CurrentConfigurationTypes);
-  if(this->CurrentConfigurationTypes.empty())
-    {
+  if (this->CurrentConfigurationTypes.empty()) {
     this->CurrentConfigurationTypes.push_back("");
-    }
+  }
 }
 
 struct cmSourceFilePathCompare
@@ -1047,72 +901,61 @@ struct cmSourceFilePathCompare
 
 struct cmCompareTargets
 {
-  bool operator () (std::string const& a, std::string const& b) const
+  bool operator()(std::string const& a, std::string const& b) const
   {
-    if (a == "ALL_BUILD")
-      {
+    if (a == "ALL_BUILD") {
       return true;
-      }
-    if (b == "ALL_BUILD")
-      {
+    }
+    if (b == "ALL_BUILD") {
       return false;
-      }
+    }
     return strcmp(a.c_str(), b.c_str()) < 0;
   }
 };
 
-bool
-cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
-                                           std::vector<cmXCodeObject*>&
-                                           targets)
+bool cmGlobalXCodeGenerator::CreateXCodeTargets(
+  cmLocalGenerator* gen, std::vector<cmXCodeObject*>& targets)
 {
   this->SetCurrentLocalGenerator(gen);
   std::vector<cmGeneratorTarget*> tgts =
-      this->CurrentLocalGenerator->GetGeneratorTargets();
+    this->CurrentLocalGenerator->GetGeneratorTargets();
   typedef std::map<std::string, cmGeneratorTarget*, cmCompareTargets>
-      cmSortedTargets;
+    cmSortedTargets;
   cmSortedTargets sortedTargets;
-  for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-      l != tgts.end(); l++)
-    {
+  for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
+       l != tgts.end(); l++) {
     sortedTargets[(*l)->GetName()] = *l;
-    }
-  for(cmSortedTargets::iterator l = sortedTargets.begin();
-      l != sortedTargets.end(); l++)
-    {
+  }
+  for (cmSortedTargets::iterator l = sortedTargets.begin();
+       l != sortedTargets.end(); l++) {
     cmGeneratorTarget* gtgt = l->second;
 
     std::string targetName = gtgt->GetName();
 
     // make sure ALL_BUILD, INSTALL, etc are only done once
-    if(this->SpecialTargetEmitted(targetName.c_str()))
-      {
+    if (this->SpecialTargetEmitted(targetName.c_str())) {
       continue;
-      }
+    }
 
-    if(gtgt->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    if (gtgt->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
 
-    if(gtgt->GetType() == cmState::UTILITY ||
-       gtgt->GetType() == cmState::GLOBAL_TARGET)
-      {
+    if (gtgt->GetType() == cmState::UTILITY ||
+        gtgt->GetType() == cmState::GLOBAL_TARGET) {
       cmXCodeObject* t = this->CreateUtilityTarget(gtgt);
-      if (!t)
-        {
+      if (!t) {
         return false;
-        }
+      }
       targets.push_back(t);
       continue;
-      }
+    }
 
     // organize the sources
     std::vector<cmSourceFile*> classes;
-    if (!gtgt->GetConfigCommonSourceFiles(classes))
-      {
+    if (!gtgt->GetConfigCommonSourceFiles(classes)) {
       return false;
-      }
+    }
     std::sort(classes.begin(), classes.end(), cmSourceFilePathCompare());
 
     gtgt->ComputeObjectMapping();
@@ -1121,66 +964,53 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
     std::vector<cmXCodeObject*> headerFiles;
     std::vector<cmXCodeObject*> resourceFiles;
     std::vector<cmXCodeObject*> sourceFiles;
-    for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
-        i != classes.end(); ++i)
-      {
+    for (std::vector<cmSourceFile*>::const_iterator i = classes.begin();
+         i != classes.end(); ++i) {
       cmXCodeObject* xsf =
-        this->CreateXCodeSourceFile(this->CurrentLocalGenerator,
-                                    *i, gtgt);
+        this->CreateXCodeSourceFile(this->CurrentLocalGenerator, *i, gtgt);
       cmXCodeObject* fr = xsf->GetObject("fileRef");
-      cmXCodeObject* filetype =
-        fr->GetObject()->GetObject("explicitFileType");
+      cmXCodeObject* filetype = fr->GetObject()->GetObject("explicitFileType");
 
       cmGeneratorTarget::SourceFileFlags tsFlags =
         gtgt->GetTargetSourceFileFlags(*i);
 
-      if(filetype &&
-         filetype->GetString() == "compiled.mach-o.objfile")
-        {
-        if ((*i)->GetObjectLibrary().empty())
-          {
+      if (filetype && filetype->GetString() == "compiled.mach-o.objfile") {
+        if ((*i)->GetObjectLibrary().empty()) {
           externalObjFiles.push_back(xsf);
-          }
         }
-      else if(this->IsHeaderFile(*i) ||
-        (tsFlags.Type == cmGeneratorTarget::SourceFileTypePrivateHeader) ||
-        (tsFlags.Type == cmGeneratorTarget::SourceFileTypePublicHeader))
-        {
+      } else if (this->IsHeaderFile(*i) ||
+                 (tsFlags.Type ==
+                  cmGeneratorTarget::SourceFileTypePrivateHeader) ||
+                 (tsFlags.Type ==
+                  cmGeneratorTarget::SourceFileTypePublicHeader)) {
         headerFiles.push_back(xsf);
-        }
-      else if(tsFlags.Type == cmGeneratorTarget::SourceFileTypeResource)
-        {
+      } else if (tsFlags.Type == cmGeneratorTarget::SourceFileTypeResource) {
         resourceFiles.push_back(xsf);
-        }
-      else if(!(*i)->GetPropertyAsBool("HEADER_FILE_ONLY"))
-        {
+      } else if (!(*i)->GetPropertyAsBool("HEADER_FILE_ONLY")) {
         // Include this file in the build if it has a known language
         // and has not been listed as an ignored extension for this
         // generator.
-        if(!this->CurrentLocalGenerator->GetSourceFileLanguage(**i).empty() &&
-           !this->IgnoreFile((*i)->GetExtension().c_str()))
-          {
+        if (!this->CurrentLocalGenerator->GetSourceFileLanguage(**i).empty() &&
+            !this->IgnoreFile((*i)->GetExtension().c_str())) {
           sourceFiles.push_back(xsf);
-          }
         }
       }
+    }
 
-    if(this->XcodeVersion < 50)
-      {
+    if (this->XcodeVersion < 50) {
       // Add object library contents as external objects. (Equivalent to
       // the externalObjFiles above, except each one is not a cmSourceFile
       // within the target.)
       std::vector<std::string> objs;
       gtgt->UseObjectLibraries(objs, "");
-      for(std::vector<std::string>::const_iterator
-            oi = objs.begin(); oi != objs.end(); ++oi)
-        {
+      for (std::vector<std::string>::const_iterator oi = objs.begin();
+           oi != objs.end(); ++oi) {
         std::string obj = *oi;
         cmXCodeObject* xsf =
           this->CreateXCodeSourceFileFromPath(obj, gtgt, "", 0);
         externalObjFiles.push_back(xsf);
-        }
       }
+    }
 
     // some build phases only apply to bundles and/or frameworks
     bool isFrameworkTarget = gtgt->IsFrameworkOnApple();
@@ -1191,126 +1021,110 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
 
     // create source build phase
     cmXCodeObject* sourceBuildPhase = 0;
-    if (!sourceFiles.empty())
-      {
+    if (!sourceFiles.empty()) {
       sourceBuildPhase =
         this->CreateObject(cmXCodeObject::PBXSourcesBuildPhase);
       sourceBuildPhase->SetComment("Sources");
       sourceBuildPhase->AddAttribute("buildActionMask",
                                      this->CreateString("2147483647"));
       buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
-      for(std::vector<cmXCodeObject*>::iterator i = sourceFiles.begin();
-          i != sourceFiles.end(); ++i)
-        {
+      for (std::vector<cmXCodeObject*>::iterator i = sourceFiles.begin();
+           i != sourceFiles.end(); ++i) {
         buildFiles->AddObject(*i);
-        }
+      }
       sourceBuildPhase->AddAttribute("files", buildFiles);
       sourceBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
                                      this->CreateString("0"));
-      }
+    }
 
     // create header build phase - only for framework targets
     cmXCodeObject* headerBuildPhase = 0;
-    if (!headerFiles.empty() && isFrameworkTarget)
-      {
+    if (!headerFiles.empty() && isFrameworkTarget) {
       headerBuildPhase =
         this->CreateObject(cmXCodeObject::PBXHeadersBuildPhase);
       headerBuildPhase->SetComment("Headers");
       headerBuildPhase->AddAttribute("buildActionMask",
                                      this->CreateString("2147483647"));
       buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
-      for(std::vector<cmXCodeObject*>::iterator i = headerFiles.begin();
-          i != headerFiles.end(); ++i)
-        {
+      for (std::vector<cmXCodeObject*>::iterator i = headerFiles.begin();
+           i != headerFiles.end(); ++i) {
         buildFiles->AddObject(*i);
-        }
+      }
       headerBuildPhase->AddAttribute("files", buildFiles);
       headerBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
                                      this->CreateString("0"));
-      }
+    }
 
     // create resource build phase - only for framework or bundle targets
     cmXCodeObject* resourceBuildPhase = 0;
     if (!resourceFiles.empty() &&
-        (isFrameworkTarget || isBundleTarget || isCFBundleTarget))
-      {
+        (isFrameworkTarget || isBundleTarget || isCFBundleTarget)) {
       resourceBuildPhase =
         this->CreateObject(cmXCodeObject::PBXResourcesBuildPhase);
       resourceBuildPhase->SetComment("Resources");
       resourceBuildPhase->AddAttribute("buildActionMask",
                                        this->CreateString("2147483647"));
       buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
-      for(std::vector<cmXCodeObject*>::iterator i = resourceFiles.begin();
-          i != resourceFiles.end(); ++i)
-        {
+      for (std::vector<cmXCodeObject*>::iterator i = resourceFiles.begin();
+           i != resourceFiles.end(); ++i) {
         buildFiles->AddObject(*i);
-        }
+      }
       resourceBuildPhase->AddAttribute("files", buildFiles);
       resourceBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
-                                     this->CreateString("0"));
-      }
+                                       this->CreateString("0"));
+    }
 
     // create vector of "non-resource content file" build phases - only for
     // framework or bundle targets
     std::vector<cmXCodeObject*> contentBuildPhases;
-    if (isFrameworkTarget || isBundleTarget || isCFBundleTarget)
-      {
+    if (isFrameworkTarget || isBundleTarget || isCFBundleTarget) {
       typedef std::map<std::string, std::vector<cmSourceFile*> >
         mapOfVectorOfSourceFiles;
       mapOfVectorOfSourceFiles bundleFiles;
-      for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
-          i != classes.end(); ++i)
-        {
+      for (std::vector<cmSourceFile*>::const_iterator i = classes.begin();
+           i != classes.end(); ++i) {
         cmGeneratorTarget::SourceFileFlags tsFlags =
           gtgt->GetTargetSourceFileFlags(*i);
-        if(tsFlags.Type == cmGeneratorTarget::SourceFileTypeMacContent)
-          {
+        if (tsFlags.Type == cmGeneratorTarget::SourceFileTypeMacContent) {
           bundleFiles[tsFlags.MacFolder].push_back(*i);
-          }
         }
+      }
       mapOfVectorOfSourceFiles::iterator mit;
-      for ( mit = bundleFiles.begin(); mit != bundleFiles.end(); ++ mit )
-        {
+      for (mit = bundleFiles.begin(); mit != bundleFiles.end(); ++mit) {
         cmXCodeObject* copyFilesBuildPhase =
           this->CreateObject(cmXCodeObject::PBXCopyFilesBuildPhase);
         copyFilesBuildPhase->SetComment("Copy files");
         copyFilesBuildPhase->AddAttribute("buildActionMask",
-          this->CreateString("2147483647"));
+                                          this->CreateString("2147483647"));
         copyFilesBuildPhase->AddAttribute("dstSubfolderSpec",
-          this->CreateString("6"));
+                                          this->CreateString("6"));
         std::ostringstream ostr;
-        if (gtgt->IsFrameworkOnApple())
-          {
+        if (gtgt->IsFrameworkOnApple()) {
           // dstPath in frameworks is relative to Versions/<version>
           ostr << mit->first;
-          }
-        else if ( mit->first != "MacOS" )
-          {
+        } else if (mit->first != "MacOS") {
           // dstPath in bundles is relative to Contents/MacOS
           ostr << "../" << mit->first.c_str();
-          }
+        }
         copyFilesBuildPhase->AddAttribute("dstPath",
-          this->CreateString(ostr.str()));
-        copyFilesBuildPhase->AddAttribute(
-          "runOnlyForDeploymentPostprocessing", this->CreateString("0"));
+                                          this->CreateString(ostr.str()));
+        copyFilesBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
+                                          this->CreateString("0"));
         buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
         copyFilesBuildPhase->AddAttribute("files", buildFiles);
         std::vector<cmSourceFile*>::iterator sfIt;
-        for ( sfIt = mit->second.begin(); sfIt != mit->second.end(); ++ sfIt )
-          {
-          cmXCodeObject* xsf =
-            this->CreateXCodeSourceFile(this->CurrentLocalGenerator,
-                                        *sfIt, gtgt);
+        for (sfIt = mit->second.begin(); sfIt != mit->second.end(); ++sfIt) {
+          cmXCodeObject* xsf = this->CreateXCodeSourceFile(
+            this->CurrentLocalGenerator, *sfIt, gtgt);
           buildFiles->AddObject(xsf);
-          }
-        contentBuildPhases.push_back(copyFilesBuildPhase);
         }
+        contentBuildPhases.push_back(copyFilesBuildPhase);
       }
+    }
 
     // create framework build phase
     cmXCodeObject* frameworkBuildPhase = 0;
-    if (!externalObjFiles.empty())
-      {
+    if (!externalObjFiles.empty()) {
       frameworkBuildPhase =
         this->CreateObject(cmXCodeObject::PBXFrameworksBuildPhase);
       frameworkBuildPhase->SetComment("Frameworks");
@@ -1318,66 +1132,63 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
                                         this->CreateString("2147483647"));
       buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
       frameworkBuildPhase->AddAttribute("files", buildFiles);
-      for(std::vector<cmXCodeObject*>::iterator i =  externalObjFiles.begin();
-          i != externalObjFiles.end(); ++i)
-        {
+      for (std::vector<cmXCodeObject*>::iterator i = externalObjFiles.begin();
+           i != externalObjFiles.end(); ++i) {
         buildFiles->AddObject(*i);
-        }
+      }
       frameworkBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
                                         this->CreateString("0"));
-      }
+    }
 
     // create list of build phases and create the Xcode target
     cmXCodeObject* buildPhases =
       this->CreateObject(cmXCodeObject::OBJECT_LIST);
 
-    this->CreateCustomCommands(buildPhases, sourceBuildPhase,
-                               headerBuildPhase, resourceBuildPhase,
-                               contentBuildPhases,
+    this->CreateCustomCommands(buildPhases, sourceBuildPhase, headerBuildPhase,
+                               resourceBuildPhase, contentBuildPhases,
                                frameworkBuildPhase, gtgt);
 
     targets.push_back(this->CreateXCodeTarget(gtgt, buildPhases));
-    }
+  }
   return true;
 }
 
 void cmGlobalXCodeGenerator::ForceLinkerLanguages()
 {
-  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
     std::vector<cmGeneratorTarget*> tgts =
-        this->LocalGenerators[i]->GetGeneratorTargets();
+      this->LocalGenerators[i]->GetGeneratorTargets();
     // All targets depend on the build-system check target.
-    for(std::vector<cmGeneratorTarget*>::const_iterator ti = tgts.begin();
-        ti != tgts.end(); ++ti)
-      {
+    for (std::vector<cmGeneratorTarget*>::const_iterator ti = tgts.begin();
+         ti != tgts.end(); ++ti) {
       // This makes sure all targets link using the proper language.
       this->ForceLinkerLanguage(*ti);
-      }
     }
+  }
 }
 
 void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmGeneratorTarget* gtgt)
 {
   // This matters only for targets that link.
-  if(gtgt->GetType() != cmState::EXECUTABLE &&
-     gtgt->GetType() != cmState::SHARED_LIBRARY &&
-     gtgt->GetType() != cmState::MODULE_LIBRARY)
-    {
+  if (gtgt->GetType() != cmState::EXECUTABLE &&
+      gtgt->GetType() != cmState::SHARED_LIBRARY &&
+      gtgt->GetType() != cmState::MODULE_LIBRARY) {
     return;
-    }
+  }
 
   std::string llang = gtgt->GetLinkerLanguage("NOCONFIG");
-  if(llang.empty()) { return; }
+  if (llang.empty()) {
+    return;
+  }
 
   // If the language is compiled as a source trust Xcode to link with it.
-  cmLinkImplementation const* impl =
-    gtgt->GetLinkImplementation("NOCONFIG");
-  for(std::vector<std::string>::const_iterator li = impl->Languages.begin();
-      li != impl->Languages.end(); ++li)
-    {
-    if(*li == llang) { return; }
+  cmLinkImplementation const* impl = gtgt->GetLinkImplementation("NOCONFIG");
+  for (std::vector<std::string>::const_iterator li = impl->Languages.begin();
+       li != impl->Languages.end(); ++li) {
+    if (*li == llang) {
+      return;
     }
+  }
 
   // Add an empty source file to the target that compiles with the
   // linker language.  This should convince Xcode to choose the proper
@@ -1391,14 +1202,13 @@ void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmGeneratorTarget* gtgt)
   fname += ".";
   fname += cmSystemTools::LowerCase(llang);
   {
-  cmGeneratedFileStream fout(fname.c_str());
-  fout << "\n";
+    cmGeneratedFileStream fout(fname.c_str());
+    fout << "\n";
   }
-  if(cmSourceFile* sf = mf->GetOrCreateSource(fname.c_str()))
-    {
+  if (cmSourceFile* sf = mf->GetOrCreateSource(fname.c_str())) {
     sf->SetProperty("LANGUAGE", llang.c_str());
     gtgt->AddSource(fname);
-    }
+  }
 }
 
 bool cmGlobalXCodeGenerator::IsHeaderFile(cmSourceFile* sf)
@@ -1409,57 +1219,39 @@ bool cmGlobalXCodeGenerator::IsHeaderFile(cmSourceFile* sf)
           hdrExts.end());
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateBuildPhase(const char* name,
-                                         const char* name2,
-                                         cmGeneratorTarget* target,
-                                         const std::vector<cmCustomCommand>&
-                                         commands)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateBuildPhase(
+  const char* name, const char* name2, cmGeneratorTarget* target,
+  const std::vector<cmCustomCommand>& commands)
 {
-  if(commands.size() == 0 && strcmp(name, "CMake ReRun") != 0)
-    {
+  if (commands.size() == 0 && strcmp(name, "CMake ReRun") != 0) {
     return 0;
-    }
+  }
   cmXCodeObject* buildPhase =
     this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
   buildPhase->AddAttribute("buildActionMask",
                            this->CreateString("2147483647"));
   cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   buildPhase->AddAttribute("files", buildFiles);
-  buildPhase->AddAttribute("name",
-                           this->CreateString(name));
+  buildPhase->AddAttribute("name", this->CreateString(name));
   buildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
                            this->CreateString("0"));
-  buildPhase->AddAttribute("shellPath",
-                           this->CreateString("/bin/sh"));
-  this->AddCommandsToBuildPhase(buildPhase, target, commands,
-                                name2);
+  buildPhase->AddAttribute("shellPath", this->CreateString("/bin/sh"));
+  this->AddCommandsToBuildPhase(buildPhase, target, commands, name2);
   return buildPhase;
 }
 
-void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases,
-                                                  cmXCodeObject*
-                                                  sourceBuildPhase,
-                                                  cmXCodeObject*
-                                                  headerBuildPhase,
-                                                  cmXCodeObject*
-                                                  resourceBuildPhase,
-                                                  std::vector<cmXCodeObject*>
-                                                  contentBuildPhases,
-                                                  cmXCodeObject*
-                                                  frameworkBuildPhase,
-                                                  cmGeneratorTarget* gtgt)
-{
-  std::vector<cmCustomCommand> const & prebuild
-    = gtgt->GetPreBuildCommands();
-  std::vector<cmCustomCommand> const & prelink
-    = gtgt->GetPreLinkCommands();
-  std::vector<cmCustomCommand> postbuild
-    = gtgt->GetPostBuildCommands();
-
-  if(gtgt->GetType() == cmState::SHARED_LIBRARY &&
-    !gtgt->IsFrameworkOnApple())
-    {
+void cmGlobalXCodeGenerator::CreateCustomCommands(
+  cmXCodeObject* buildPhases, cmXCodeObject* sourceBuildPhase,
+  cmXCodeObject* headerBuildPhase, cmXCodeObject* resourceBuildPhase,
+  std::vector<cmXCodeObject*> contentBuildPhases,
+  cmXCodeObject* frameworkBuildPhase, cmGeneratorTarget* gtgt)
+{
+  std::vector<cmCustomCommand> const& prebuild = gtgt->GetPreBuildCommands();
+  std::vector<cmCustomCommand> const& prelink = gtgt->GetPreLinkCommands();
+  std::vector<cmCustomCommand> postbuild = gtgt->GetPostBuildCommands();
+
+  if (gtgt->GetType() == cmState::SHARED_LIBRARY &&
+      !gtgt->IsFrameworkOnApple()) {
     cmCustomCommandLines cmd;
     cmd.resize(1);
     cmd[0].push_back(cmSystemTools::GetCMakeCommand());
@@ -1478,92 +1270,72 @@ void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases,
     cmd[0].push_back(str_so_file);
     cmd[0].push_back(str_link_file);
 
-    cmCustomCommand command(this->CurrentMakefile,
-      std::vector<std::string>(),
-      std::vector<std::string>(),
-      std::vector<std::string>(),
-      cmd,
-      "Creating symlinks",
-      "");
+    cmCustomCommand command(this->CurrentMakefile, std::vector<std::string>(),
+                            std::vector<std::string>(),
+                            std::vector<std::string>(), cmd,
+                            "Creating symlinks", "");
 
     postbuild.push_back(command);
-    }
+  }
 
   std::vector<cmSourceFile*> classes;
-  if (!gtgt->GetConfigCommonSourceFiles(classes))
-    {
+  if (!gtgt->GetConfigCommonSourceFiles(classes)) {
     return;
-    }
+  }
   // add all the sources
   std::vector<cmCustomCommand> commands;
-  for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
-      i != classes.end(); ++i)
-    {
-    if((*i)->GetCustomCommand())
-      {
+  for (std::vector<cmSourceFile*>::const_iterator i = classes.begin();
+       i != classes.end(); ++i) {
+    if ((*i)->GetCustomCommand()) {
       commands.push_back(*(*i)->GetCustomCommand());
-      }
     }
+  }
   // create prebuild phase
-  cmXCodeObject* cmakeRulesBuildPhase =
-    this->CreateBuildPhase("CMake Rules",
-                           "cmakeRulesBuildPhase",
-                           gtgt, commands);
+  cmXCodeObject* cmakeRulesBuildPhase = this->CreateBuildPhase(
+    "CMake Rules", "cmakeRulesBuildPhase", gtgt, commands);
   // create prebuild phase
-  cmXCodeObject* preBuildPhase =
-    this->CreateBuildPhase("CMake PreBuild Rules", "preBuildCommands",
-                           gtgt, prebuild);
+  cmXCodeObject* preBuildPhase = this->CreateBuildPhase(
+    "CMake PreBuild Rules", "preBuildCommands", gtgt, prebuild);
   // create prelink phase
-  cmXCodeObject* preLinkPhase =
-    this->CreateBuildPhase("CMake PreLink Rules", "preLinkCommands",
-                           gtgt, prelink);
+  cmXCodeObject* preLinkPhase = this->CreateBuildPhase(
+    "CMake PreLink Rules", "preLinkCommands", gtgt, prelink);
   // create postbuild phase
-  cmXCodeObject* postBuildPhase =
-    this->CreateBuildPhase("CMake PostBuild Rules", "postBuildPhase",
-                           gtgt, postbuild);
+  cmXCodeObject* postBuildPhase = this->CreateBuildPhase(
+    "CMake PostBuild Rules", "postBuildPhase", gtgt, postbuild);
 
   // The order here is the order they will be built in.
   // The order "headers, resources, sources" mimics a native project generated
   // from an xcode template...
   //
-  if(preBuildPhase)
-    {
+  if (preBuildPhase) {
     buildPhases->AddObject(preBuildPhase);
-    }
-  if(cmakeRulesBuildPhase)
-    {
+  }
+  if (cmakeRulesBuildPhase) {
     buildPhases->AddObject(cmakeRulesBuildPhase);
-    }
-  if(headerBuildPhase)
-    {
+  }
+  if (headerBuildPhase) {
     buildPhases->AddObject(headerBuildPhase);
-    }
-  if(resourceBuildPhase)
-    {
+  }
+  if (resourceBuildPhase) {
     buildPhases->AddObject(resourceBuildPhase);
-    }
+  }
   std::vector<cmXCodeObject*>::iterator cit;
   for (cit = contentBuildPhases.begin(); cit != contentBuildPhases.end();
-       ++cit)
-    {
+       ++cit) {
     buildPhases->AddObject(*cit);
-    }
-  if(sourceBuildPhase)
-    {
+  }
+  if (sourceBuildPhase) {
     buildPhases->AddObject(sourceBuildPhase);
-    }
-  if(preLinkPhase)
-    {
+  }
+  if (preLinkPhase) {
     buildPhases->AddObject(preLinkPhase);
-    }
-  if(frameworkBuildPhase)
-    {
+  }
+  if (frameworkBuildPhase) {
     buildPhases->AddObject(frameworkBuildPhase);
-    }
-  if(postBuildPhase)
-    {
+  }
+  if (postBuildPhase) {
     buildPhases->AddObject(postBuildPhase);
-    }
+  }
 }
 
 // This function removes each occurrence of the flag and returns the last one
@@ -1574,28 +1346,25 @@ std::string cmGlobalXCodeGenerator::ExtractFlag(const char* flag,
   std::string retFlag;
   std::string::size_type lastOccurancePos = flags.rfind(flag);
   bool saved = false;
-  while(lastOccurancePos != flags.npos)
-    {
-    //increment pos, we use lastOccurancePos to reduce search space on next inc
+  while (lastOccurancePos != flags.npos) {
+    // increment pos, we use lastOccurancePos to reduce search space on next
+    // inc
     std::string::size_type pos = lastOccurancePos;
-    if(pos == 0 || flags[pos-1]==' ')
-      {
-      while(pos < flags.size() && flags[pos] != ' ')
-        {
-        if(!saved)
-          {
+    if (pos == 0 || flags[pos - 1] == ' ') {
+      while (pos < flags.size() && flags[pos] != ' ') {
+        if (!saved) {
           retFlag += flags[pos];
-          }
+        }
         flags[pos] = ' ';
         pos++;
-        }
-      saved = true;
       }
-    //decrement lastOccurancePos while making sure we don't loop around
-    //and become a very large positive number since size_type is unsigned
-    lastOccurancePos = lastOccurancePos == 0 ? 0 : lastOccurancePos-1;
-    lastOccurancePos = flags.rfind(flag,lastOccurancePos);
+      saved = true;
     }
+    // decrement lastOccurancePos while making sure we don't loop around
+    // and become a very large positive number since size_type is unsigned
+    lastOccurancePos = lastOccurancePos == 0 ? 0 : lastOccurancePos - 1;
+    lastOccurancePos = flags.rfind(flag, lastOccurancePos);
+  }
   return retFlag;
 }
 
@@ -1609,15 +1378,13 @@ std::string cmGlobalXCodeGenerator::ExtractFlagRegex(const char* exp,
 
   cmsys::RegularExpression regex(exp);
   assert(regex.is_valid());
-  if(!regex.is_valid())
-    {
+  if (!regex.is_valid()) {
     return retFlag;
-    }
+  }
 
   std::string::size_type offset = 0;
 
-  while(regex.find(flags.c_str() + offset))
-    {
+  while (regex.find(flags.c_str() + offset)) {
     const std::string::size_type startPos = offset + regex.start(matchIndex);
     const std::string::size_type endPos = offset + regex.end(matchIndex);
     const std::string::size_type size = endPos - startPos;
@@ -1626,57 +1393,47 @@ std::string cmGlobalXCodeGenerator::ExtractFlagRegex(const char* exp,
 
     retFlag.assign(flags, startPos, size);
     flags.replace(startPos, size, size, ' ');
-    }
+  }
 
   return retFlag;
 }
 
- //----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 // This function strips off Xcode attributes that do not target the current
 // configuration
-void
-cmGlobalXCodeGenerator
-::FilterConfigurationAttribute(std::string const& configName,
-                               std::string& attribute)
+void cmGlobalXCodeGenerator::FilterConfigurationAttribute(
+  std::string const& configName, std::string& attribute)
 {
   // Handle [variant=<config>] condition explicitly here.
   std::string::size_type beginVariant = attribute.find("[variant=");
-  if (beginVariant == std::string::npos)
-    {
+  if (beginVariant == std::string::npos) {
     // There is no variant in this attribute.
     return;
-    }
+  }
 
-  std::string::size_type endVariant = attribute.find("]", beginVariant+9);
-  if (endVariant == std::string::npos)
-    {
+  std::string::size_type endVariant = attribute.find("]", beginVariant + 9);
+  if (endVariant == std::string::npos) {
     // There is no terminating bracket.
     return;
-    }
+  }
 
   // Compare the variant to the configuration.
   std::string variant =
-    attribute.substr(beginVariant+9, endVariant-beginVariant-9);
-  if (variant == configName)
-    {
+    attribute.substr(beginVariant + 9, endVariant - beginVariant - 9);
+  if (variant == configName) {
     // The variant matches the configuration so use this
     // attribute but drop the [variant=<config>] condition.
-    attribute.erase(beginVariant, endVariant-beginVariant+1);
-    }
-  else
-    {
+    attribute.erase(beginVariant, endVariant - beginVariant + 1);
+  } else {
     // The variant does not match the configuration so
     // do not use this attribute.
     attribute.clear();
-    }
+  }
 }
 
-void
-cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase,
-                                                cmGeneratorTarget* target,
-                                                std::vector<cmCustomCommand>
-                                                const & commands,
-                                                const char* name)
+void cmGlobalXCodeGenerator::AddCommandsToBuildPhase(
+  cmXCodeObject* buildphase, cmGeneratorTarget* target,
+  std::vector<cmCustomCommand> const& commands, const char* name)
 {
   std::string dir = this->CurrentLocalGenerator->GetCurrentBinaryDirectory();
   dir += "/CMakeScripts";
@@ -1688,180 +1445,150 @@ cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase,
   makefile += name;
   makefile += ".make";
 
-  for (std::vector<std::string>::const_iterator currentConfig=
-            this->CurrentConfigurationTypes.begin();
-       currentConfig!=this->CurrentConfigurationTypes.end();
-       currentConfig++ )
-    {
-    this->CreateCustomRulesMakefile(makefile.c_str(),
-                                    target,
-                                    commands,
+  for (std::vector<std::string>::const_iterator currentConfig =
+         this->CurrentConfigurationTypes.begin();
+       currentConfig != this->CurrentConfigurationTypes.end();
+       currentConfig++) {
+    this->CreateCustomRulesMakefile(makefile.c_str(), target, commands,
                                     currentConfig->c_str());
-    }
+  }
 
   std::string cdir = this->CurrentLocalGenerator->GetCurrentBinaryDirectory();
   cdir = this->ConvertToRelativeForMake(cdir.c_str());
   std::string makecmd = "make -C ";
   makecmd += cdir;
   makecmd += " -f ";
-  makecmd += this->ConvertToRelativeForMake(
-                                          (makefile+"$CONFIGURATION").c_str());
+  makecmd +=
+    this->ConvertToRelativeForMake((makefile + "$CONFIGURATION").c_str());
   makecmd += " all";
-  buildphase->AddAttribute("shellScript",
-                           this->CreateString(makecmd));
-  buildphase->AddAttribute("showEnvVarsInLog",
-                           this->CreateString("0"));
+  buildphase->AddAttribute("shellScript", this->CreateString(makecmd));
+  buildphase->AddAttribute("showEnvVarsInLog", this->CreateString("0"));
 }
 
-void  cmGlobalXCodeGenerator
-::CreateCustomRulesMakefile(const char* makefileBasename,
-                            cmGeneratorTarget* target,
-                            std::vector<cmCustomCommand>
-                            const & commands,
-                            const std::string& configName)
+void cmGlobalXCodeGenerator::CreateCustomRulesMakefile(
+  const char* makefileBasename, cmGeneratorTarget* target,
+  std::vector<cmCustomCommand> const& commands, const std::string& configName)
 {
-  std::string makefileName=makefileBasename;
-  if(this->XcodeVersion > 20)
-    {
-    makefileName+=configName;
-    }
+  std::string makefileName = makefileBasename;
+  if (this->XcodeVersion > 20) {
+    makefileName += configName;
+  }
   cmGeneratedFileStream makefileStream(makefileName.c_str());
-  if(!makefileStream)
-    {
+  if (!makefileStream) {
     return;
-    }
+  }
   makefileStream.SetCopyIfDifferent(true);
   makefileStream << "# Generated by CMake, DO NOT EDIT\n";
   makefileStream << "# Custom rules for " << target->GetName() << "\n";
 
   // disable the implicit rules
-  makefileStream << ".SUFFIXES: " << "\n";
+  makefileStream << ".SUFFIXES: "
+                 << "\n";
 
   // have all depend on all outputs
   makefileStream << "all: ";
   std::map<const cmCustomCommand*, std::string> tname;
   int count = 0;
-  for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
-      i != commands.end(); ++i)
-    {
+  for (std::vector<cmCustomCommand>::const_iterator i = commands.begin();
+       i != commands.end(); ++i) {
     cmCustomCommandGenerator ccg(*i, configName, this->CurrentLocalGenerator);
-    if(ccg.GetNumberOfCommands() > 0)
-      {
+    if (ccg.GetNumberOfCommands() > 0) {
       const std::vector<std::string>& outputs = ccg.GetOutputs();
-      if(!outputs.empty())
-        {
-        for(std::vector<std::string>::const_iterator o = outputs.begin();
-            o != outputs.end(); ++o)
-          {
-          makefileStream
-              << "\\\n\t" << this->ConvertToRelativeForMake(o->c_str());
-          }
+      if (!outputs.empty()) {
+        for (std::vector<std::string>::const_iterator o = outputs.begin();
+             o != outputs.end(); ++o) {
+          makefileStream << "\\\n\t"
+                         << this->ConvertToRelativeForMake(o->c_str());
         }
-      else
-        {
+      } else {
         std::ostringstream str;
-        str << "_buildpart_" << count++ ;
+        str << "_buildpart_" << count++;
         tname[&ccg.GetCC()] = std::string(target->GetName()) + str.str();
         makefileStream << "\\\n\t" << tname[&ccg.GetCC()];
-        }
       }
     }
+  }
   makefileStream << "\n\n";
-  for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
-      i != commands.end(); ++i)
-    {
+  for (std::vector<cmCustomCommand>::const_iterator i = commands.begin();
+       i != commands.end(); ++i) {
     cmCustomCommandGenerator ccg(*i, configName, this->CurrentLocalGenerator);
-    if(ccg.GetNumberOfCommands() > 0)
-      {
+    if (ccg.GetNumberOfCommands() > 0) {
       makefileStream << "\n";
       const std::vector<std::string>& outputs = ccg.GetOutputs();
-      if(!outputs.empty())
-        {
+      if (!outputs.empty()) {
         // There is at least one output, start the rule for it
         const char* sep = "";
-        for(std::vector<std::string>::const_iterator oi = outputs.begin();
-            oi != outputs.end(); ++oi)
-          {
-          makefileStream << sep <<
-            this->ConvertToRelativeForMake(oi->c_str());
+        for (std::vector<std::string>::const_iterator oi = outputs.begin();
+             oi != outputs.end(); ++oi) {
+          makefileStream << sep << this->ConvertToRelativeForMake(oi->c_str());
           sep = " ";
-          }
-        makefileStream << ": ";
         }
-      else
-        {
+        makefileStream << ": ";
+      } else {
         // There are no outputs.  Use the generated force rule name.
         makefileStream << tname[&ccg.GetCC()] << ": ";
-        }
-      for(std::vector<std::string>::const_iterator d =
-          ccg.GetDepends().begin();
-          d != ccg.GetDepends().end(); ++d)
-        {
+      }
+      for (std::vector<std::string>::const_iterator d =
+             ccg.GetDepends().begin();
+           d != ccg.GetDepends().end(); ++d) {
         std::string dep;
-        if(this->CurrentLocalGenerator
-           ->GetRealDependency(d->c_str(), configName, dep))
-          {
-          makefileStream << "\\\n" <<
-            this->ConvertToRelativeForMake(dep.c_str());
-          }
+        if (this->CurrentLocalGenerator->GetRealDependency(d->c_str(),
+                                                           configName, dep)) {
+          makefileStream << "\\\n"
+                         << this->ConvertToRelativeForMake(dep.c_str());
         }
+      }
       makefileStream << "\n";
 
-      if(const char* comment = ccg.GetComment())
-        {
+      if (const char* comment = ccg.GetComment()) {
         std::string echo_cmd = "echo ";
-        echo_cmd += (this->CurrentLocalGenerator->
-          EscapeForShell(comment, ccg.GetCC().GetEscapeAllowMakeVars()));
+        echo_cmd += (this->CurrentLocalGenerator->EscapeForShell(
+          comment, ccg.GetCC().GetEscapeAllowMakeVars()));
         makefileStream << "\t" << echo_cmd.c_str() << "\n";
-        }
+      }
 
       // Add each command line to the set of commands.
-      for(unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c)
-        {
+      for (unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c) {
         // Build the command line in a single string.
         std::string cmd2 = ccg.GetCommand(c);
         cmSystemTools::ReplaceString(cmd2, "/./", "/");
         cmd2 = this->ConvertToRelativeForMake(cmd2.c_str());
         std::string cmd;
         std::string wd = ccg.GetWorkingDirectory();
-        if(!wd.empty())
-          {
+        if (!wd.empty()) {
           cmd += "cd ";
           cmd += this->ConvertToRelativeForMake(wd.c_str());
           cmd += " && ";
-          }
+        }
         cmd += cmd2;
         ccg.AppendArguments(c, cmd);
         makefileStream << "\t" << cmd.c_str() << "\n";
-        }
       }
     }
+  }
 }
 
 void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
-                                                cmXCodeObject* buildSettings,
-                                                const std::string& configName)
+                                                 cmXCodeObject* buildSettings,
+                                                 const std::string& configName)
 {
-  if(gtgt->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (gtgt->GetType() == cmState::INTERFACE_LIBRARY) {
     return;
-    }
+  }
 
   std::string defFlags;
   bool shared = ((gtgt->GetType() == cmState::SHARED_LIBRARY) ||
                  (gtgt->GetType() == cmState::MODULE_LIBRARY));
   bool binary = ((gtgt->GetType() == cmState::OBJECT_LIBRARY) ||
                  (gtgt->GetType() == cmState::STATIC_LIBRARY) ||
-                 (gtgt->GetType() == cmState::EXECUTABLE) ||
-                 shared);
+                 (gtgt->GetType() == cmState::EXECUTABLE) || shared);
 
   // Compute the compilation flags for each language.
   std::set<std::string> languages;
   gtgt->GetLanguages(languages, configName);
   std::map<std::string, std::string> cflags;
   for (std::set<std::string>::iterator li = languages.begin();
-       li != languages.end(); ++li)
-    {
+       li != languages.end(); ++li) {
     std::string const& lang = *li;
     std::string& flags = cflags[lang];
 
@@ -1869,126 +1596,97 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
     this->CurrentLocalGenerator->AddLanguageFlags(flags, lang, configName);
 
     // Add shared-library flags if needed.
-    this->CurrentLocalGenerator->AddCMP0018Flags(flags, gtgt,
-                                                 lang, configName);
+    this->CurrentLocalGenerator->AddCMP0018Flags(flags, gtgt, lang,
+                                                 configName);
 
-    this->CurrentLocalGenerator->AddVisibilityPresetFlags(flags, gtgt,
-                                                   lang);
+    this->CurrentLocalGenerator->AddVisibilityPresetFlags(flags, gtgt, lang);
 
-    this->CurrentLocalGenerator->
-      AddCompileOptions(flags, gtgt, lang, configName);
-    }
+    this->CurrentLocalGenerator->AddCompileOptions(flags, gtgt, lang,
+                                                   configName);
+  }
 
   std::string llang = gtgt->GetLinkerLanguage(configName);
-  if(binary && llang.empty())
-    {
-    cmSystemTools::Error
-      ("CMake can not determine linker language for target: ",
-       gtgt->GetName().c_str());
+  if (binary && llang.empty()) {
+    cmSystemTools::Error(
+      "CMake can not determine linker language for target: ",
+      gtgt->GetName().c_str());
     return;
-    }
+  }
 
   // Add define flags
-  this->CurrentLocalGenerator->
-    AppendFlags(defFlags,
-                this->CurrentMakefile->GetDefineFlags());
+  this->CurrentLocalGenerator->AppendFlags(
+    defFlags, this->CurrentMakefile->GetDefineFlags());
 
   // Add preprocessor definitions for this target and configuration.
   BuildObjectListOrString ppDefs(this, this->XcodeVersion >= 30);
-  if(this->XcodeVersion > 15)
-    {
-    this->AppendDefines(ppDefs,
-      "CMAKE_INTDIR=\"$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)\"");
-    }
-  if(const char* exportMacro = gtgt->GetExportMacro())
-    {
+  if (this->XcodeVersion > 15) {
+    this->AppendDefines(
+      ppDefs, "CMAKE_INTDIR=\"$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)\"");
+  }
+  if (const char* exportMacro = gtgt->GetExportMacro()) {
     // Add the export symbol definition for shared library objects.
     this->AppendDefines(ppDefs, exportMacro);
-    }
+  }
   std::vector<std::string> targetDefines;
   gtgt->GetCompileDefinitions(targetDefines, configName, "C");
   this->AppendDefines(ppDefs, targetDefines);
-  buildSettings->AddAttribute
-    ("GCC_PREPROCESSOR_DEFINITIONS", ppDefs.CreateList());
+  buildSettings->AddAttribute("GCC_PREPROCESSOR_DEFINITIONS",
+                              ppDefs.CreateList());
 
   std::string extraLinkOptionsVar;
   std::string extraLinkOptions;
-  if(gtgt->GetType() == cmState::EXECUTABLE)
-    {
+  if (gtgt->GetType() == cmState::EXECUTABLE) {
     extraLinkOptionsVar = "CMAKE_EXE_LINKER_FLAGS";
-    }
-  else if(gtgt->GetType() == cmState::SHARED_LIBRARY)
-    {
+  } else if (gtgt->GetType() == cmState::SHARED_LIBRARY) {
     extraLinkOptionsVar = "CMAKE_SHARED_LINKER_FLAGS";
-    }
-  else if(gtgt->GetType() == cmState::MODULE_LIBRARY)
-    {
+  } else if (gtgt->GetType() == cmState::MODULE_LIBRARY) {
     extraLinkOptionsVar = "CMAKE_MODULE_LINKER_FLAGS";
-    }
-  if(!extraLinkOptionsVar.empty())
-    {
-    this->CurrentLocalGenerator
-      ->AddConfigVariableFlags(extraLinkOptions,
-                               extraLinkOptionsVar.c_str(),
-                               configName);
-    }
+  }
+  if (!extraLinkOptionsVar.empty()) {
+    this->CurrentLocalGenerator->AddConfigVariableFlags(
+      extraLinkOptions, extraLinkOptionsVar.c_str(), configName);
+  }
 
-  if(gtgt->GetType() == cmState::OBJECT_LIBRARY ||
-     gtgt->GetType() == cmState::STATIC_LIBRARY)
-    {
-    this->CurrentLocalGenerator
-      ->GetStaticLibraryFlags(extraLinkOptions,
-                              cmSystemTools::UpperCase(configName),
-                              gtgt);
-    }
-  else
-    {
+  if (gtgt->GetType() == cmState::OBJECT_LIBRARY ||
+      gtgt->GetType() == cmState::STATIC_LIBRARY) {
+    this->CurrentLocalGenerator->GetStaticLibraryFlags(
+      extraLinkOptions, cmSystemTools::UpperCase(configName), gtgt);
+  } else {
     const char* targetLinkFlags = gtgt->GetProperty("LINK_FLAGS");
-    if(targetLinkFlags)
-      {
-      this->CurrentLocalGenerator->
-        AppendFlags(extraLinkOptions, targetLinkFlags);
-      }
-    if(!configName.empty())
-      {
+    if (targetLinkFlags) {
+      this->CurrentLocalGenerator->AppendFlags(extraLinkOptions,
+                                               targetLinkFlags);
+    }
+    if (!configName.empty()) {
       std::string linkFlagsVar = "LINK_FLAGS_";
       linkFlagsVar += cmSystemTools::UpperCase(configName);
-      if(const char* linkFlags = gtgt->GetProperty(linkFlagsVar.c_str()))
-        {
-        this->CurrentLocalGenerator->
-          AppendFlags(extraLinkOptions, linkFlags);
-        }
+      if (const char* linkFlags = gtgt->GetProperty(linkFlagsVar.c_str())) {
+        this->CurrentLocalGenerator->AppendFlags(extraLinkOptions, linkFlags);
       }
     }
+  }
 
   // Set target-specific architectures.
   std::vector<std::string> archs;
   gtgt->GetAppleArchs(configName, archs);
 
-  if(!archs.empty())
-    {
+  if (!archs.empty()) {
     // Enable ARCHS attribute.
-    buildSettings->AddAttribute("ONLY_ACTIVE_ARCH",
-                                this->CreateString("NO"));
+    buildSettings->AddAttribute("ONLY_ACTIVE_ARCH", this->CreateString("NO"));
 
     // Store ARCHS value.
-    if(archs.size() == 1)
-      {
-      buildSettings->AddAttribute("ARCHS",
-                                  this->CreateString(archs[0]));
-      }
-    else
-      {
+    if (archs.size() == 1) {
+      buildSettings->AddAttribute("ARCHS", this->CreateString(archs[0]));
+    } else {
       cmXCodeObject* archObjects =
         this->CreateObject(cmXCodeObject::OBJECT_LIST);
-      for(std::vector<std::string>::iterator i = archs.begin();
-          i != archs.end(); i++)
-        {
+      for (std::vector<std::string>::iterator i = archs.begin();
+           i != archs.end(); i++) {
         archObjects->AddObject(this->CreateString(*i));
-        }
-      buildSettings->AddAttribute("ARCHS", archObjects);
       }
+      buildSettings->AddAttribute("ARCHS", archObjects);
     }
+  }
 
   // Get the product name components.
   std::string pnprefix;
@@ -1998,280 +1696,219 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
 
   const char* version = gtgt->GetProperty("VERSION");
   const char* soversion = gtgt->GetProperty("SOVERSION");
-  if(!gtgt->HasSOName(configName) || gtgt->IsFrameworkOnApple())
-    {
+  if (!gtgt->HasSOName(configName) || gtgt->IsFrameworkOnApple()) {
     version = 0;
     soversion = 0;
-    }
-  if(version && !soversion)
-    {
+  }
+  if (version && !soversion) {
     soversion = version;
-    }
-  if(!version && soversion)
-    {
+  }
+  if (!version && soversion) {
     version = soversion;
-    }
+  }
 
   std::string realName = pnbase;
   std::string soName = pnbase;
-  if(version && soversion)
-    {
+  if (version && soversion) {
     realName += ".";
     realName += version;
     soName += ".";
     soName += soversion;
-    }
+  }
 
   // Set attributes to specify the proper name for the target.
   std::string pndir = this->CurrentLocalGenerator->GetCurrentBinaryDirectory();
-  if(gtgt->GetType() == cmState::STATIC_LIBRARY ||
-     gtgt->GetType() == cmState::SHARED_LIBRARY ||
-     gtgt->GetType() == cmState::MODULE_LIBRARY ||
-     gtgt->GetType() == cmState::EXECUTABLE)
-    {
-    if(this->XcodeVersion >= 21)
-      {
-      if(!gtgt->UsesDefaultOutputDir(configName, false))
-        {
+  if (gtgt->GetType() == cmState::STATIC_LIBRARY ||
+      gtgt->GetType() == cmState::SHARED_LIBRARY ||
+      gtgt->GetType() == cmState::MODULE_LIBRARY ||
+      gtgt->GetType() == cmState::EXECUTABLE) {
+    if (this->XcodeVersion >= 21) {
+      if (!gtgt->UsesDefaultOutputDir(configName, false)) {
         std::string pncdir = gtgt->GetDirectory(configName);
         buildSettings->AddAttribute("CONFIGURATION_BUILD_DIR",
                                     this->CreateString(pncdir));
-        }
       }
-    else
-      {
-      buildSettings->AddAttribute("OBJROOT",
-                                  this->CreateString(pndir));
+    } else {
+      buildSettings->AddAttribute("OBJROOT", this->CreateString(pndir));
       pndir = gtgt->GetDirectory(configName);
-      }
+    }
 
-    if(gtgt->IsFrameworkOnApple() || gtgt->IsCFBundleOnApple())
-      {
+    if (gtgt->IsFrameworkOnApple() || gtgt->IsCFBundleOnApple()) {
       pnprefix = "";
-      }
+    }
 
     buildSettings->AddAttribute("EXECUTABLE_PREFIX",
                                 this->CreateString(pnprefix));
     buildSettings->AddAttribute("EXECUTABLE_SUFFIX",
                                 this->CreateString(pnsuffix));
-    }
-  else if(gtgt->GetType() == cmState::OBJECT_LIBRARY)
-    {
+  } else if (gtgt->GetType() == cmState::OBJECT_LIBRARY) {
     pnprefix = "lib";
     pnbase = gtgt->GetName();
     pnsuffix = ".a";
 
-    if(this->XcodeVersion >= 21)
-      {
+    if (this->XcodeVersion >= 21) {
       std::string pncdir = this->GetObjectsNormalDirectory(
         this->CurrentProject, configName, gtgt);
       buildSettings->AddAttribute("CONFIGURATION_BUILD_DIR",
                                   this->CreateString(pncdir));
-      }
-    else
-      {
-      buildSettings->AddAttribute("OBJROOT",
-                                  this->CreateString(pndir));
-      pndir = this->GetObjectsNormalDirectory(
-        this->CurrentProject, configName, gtgt);
-      }
+    } else {
+      buildSettings->AddAttribute("OBJROOT", this->CreateString(pndir));
+      pndir = this->GetObjectsNormalDirectory(this->CurrentProject, configName,
+                                              gtgt);
     }
+  }
 
   // Store the product name for all target types.
-  buildSettings->AddAttribute("PRODUCT_NAME",
-                              this->CreateString(realName));
-  buildSettings->AddAttribute("SYMROOT",
-                              this->CreateString(pndir));
+  buildSettings->AddAttribute("PRODUCT_NAME", this->CreateString(realName));
+  buildSettings->AddAttribute("SYMROOT", this->CreateString(pndir));
 
   // Handle settings for each target type.
-  switch(gtgt->GetType())
-    {
+  switch (gtgt->GetType()) {
     case cmState::OBJECT_LIBRARY:
-    case cmState::STATIC_LIBRARY:
-    {
-    buildSettings->AddAttribute("LIBRARY_STYLE",
-                                this->CreateString("STATIC"));
-    break;
+    case cmState::STATIC_LIBRARY: {
+      buildSettings->AddAttribute("LIBRARY_STYLE",
+                                  this->CreateString("STATIC"));
+      break;
     }
 
-    case cmState::MODULE_LIBRARY:
-    {
-    buildSettings->AddAttribute("LIBRARY_STYLE",
-                                this->CreateString("BUNDLE"));
-    if (gtgt->IsCFBundleOnApple())
-      {
-      // It turns out that a BUNDLE is basically the same
-      // in many ways as an application bundle, as far as
-      // link flags go
-      std::string createFlags =
-        this->LookupFlags("CMAKE_SHARED_MODULE_CREATE_", llang, "_FLAGS",
-                          "-bundle");
-      if(!createFlags.empty())
-        {
-        extraLinkOptions += " ";
-        extraLinkOptions += createFlags;
-        }
-      std::string plist = this->ComputeInfoPListLocation(gtgt);
-      // Xcode will create the final version of Info.plist at build time,
-      // so let it replace the cfbundle name. This avoids creating
-      // a per-configuration Info.plist file. The cfbundle plist
-      // is very similar to the application bundle plist
-      this->CurrentLocalGenerator
-        ->GenerateAppleInfoPList(gtgt, "$(EXECUTABLE_NAME)",
-                                 plist.c_str());
-      buildSettings->AddAttribute("INFOPLIST_FILE",
-                                  this->CreateString(plist));
-      }
-    else if(this->XcodeVersion >= 22)
-      {
-      buildSettings->AddAttribute("MACH_O_TYPE",
-                                  this->CreateString("mh_bundle"));
-      buildSettings->AddAttribute("GCC_DYNAMIC_NO_PIC",
-                                  this->CreateString("NO"));
-      // Add the flags to create an executable.
-      std::string createFlags =
-        this->LookupFlags("CMAKE_", llang, "_LINK_FLAGS", "");
-      if(!createFlags.empty())
-        {
-        extraLinkOptions += " ";
-        extraLinkOptions += createFlags;
+    case cmState::MODULE_LIBRARY: {
+      buildSettings->AddAttribute("LIBRARY_STYLE",
+                                  this->CreateString("BUNDLE"));
+      if (gtgt->IsCFBundleOnApple()) {
+        // It turns out that a BUNDLE is basically the same
+        // in many ways as an application bundle, as far as
+        // link flags go
+        std::string createFlags = this->LookupFlags(
+          "CMAKE_SHARED_MODULE_CREATE_", llang, "_FLAGS", "-bundle");
+        if (!createFlags.empty()) {
+          extraLinkOptions += " ";
+          extraLinkOptions += createFlags;
         }
-      }
-    else
-      {
-      // Add the flags to create a module.
-      std::string createFlags =
-        this->LookupFlags("CMAKE_SHARED_MODULE_CREATE_", llang, "_FLAGS",
-                          "-bundle");
-      if(!createFlags.empty())
-        {
-        extraLinkOptions += " ";
-        extraLinkOptions += createFlags;
+        std::string plist = this->ComputeInfoPListLocation(gtgt);
+        // Xcode will create the final version of Info.plist at build time,
+        // so let it replace the cfbundle name. This avoids creating
+        // a per-configuration Info.plist file. The cfbundle plist
+        // is very similar to the application bundle plist
+        this->CurrentLocalGenerator->GenerateAppleInfoPList(
+          gtgt, "$(EXECUTABLE_NAME)", plist.c_str());
+        buildSettings->AddAttribute("INFOPLIST_FILE",
+                                    this->CreateString(plist));
+      } else if (this->XcodeVersion >= 22) {
+        buildSettings->AddAttribute("MACH_O_TYPE",
+                                    this->CreateString("mh_bundle"));
+        buildSettings->AddAttribute("GCC_DYNAMIC_NO_PIC",
+                                    this->CreateString("NO"));
+        // Add the flags to create an executable.
+        std::string createFlags =
+          this->LookupFlags("CMAKE_", llang, "_LINK_FLAGS", "");
+        if (!createFlags.empty()) {
+          extraLinkOptions += " ";
+          extraLinkOptions += createFlags;
+        }
+      } else {
+        // Add the flags to create a module.
+        std::string createFlags = this->LookupFlags(
+          "CMAKE_SHARED_MODULE_CREATE_", llang, "_FLAGS", "-bundle");
+        if (!createFlags.empty()) {
+          extraLinkOptions += " ";
+          extraLinkOptions += createFlags;
         }
       }
-    break;
+      break;
     }
-    case cmState::SHARED_LIBRARY:
-    {
-    if(gtgt->GetPropertyAsBool("FRAMEWORK"))
-      {
-      std::string fw_version = gtgt->GetFrameworkVersion();
-      buildSettings->AddAttribute("FRAMEWORK_VERSION",
-                                  this->CreateString(fw_version));
-
-      std::string plist = this->ComputeInfoPListLocation(gtgt);
-      // Xcode will create the final version of Info.plist at build time,
-      // so let it replace the framework name. This avoids creating
-      // a per-configuration Info.plist file.
-      this->CurrentLocalGenerator
-        ->GenerateFrameworkInfoPList(gtgt, "$(EXECUTABLE_NAME)",
-                                     plist.c_str());
-      buildSettings->AddAttribute("INFOPLIST_FILE",
-                                  this->CreateString(plist));
-      }
-    else
-      {
-      // Add the flags to create a shared library.
+    case cmState::SHARED_LIBRARY: {
+      if (gtgt->GetPropertyAsBool("FRAMEWORK")) {
+        std::string fw_version = gtgt->GetFrameworkVersion();
+        buildSettings->AddAttribute("FRAMEWORK_VERSION",
+                                    this->CreateString(fw_version));
+
+        std::string plist = this->ComputeInfoPListLocation(gtgt);
+        // Xcode will create the final version of Info.plist at build time,
+        // so let it replace the framework name. This avoids creating
+        // a per-configuration Info.plist file.
+        this->CurrentLocalGenerator->GenerateFrameworkInfoPList(
+          gtgt, "$(EXECUTABLE_NAME)", plist.c_str());
+        buildSettings->AddAttribute("INFOPLIST_FILE",
+                                    this->CreateString(plist));
+      } else {
+        // Add the flags to create a shared library.
+        std::string createFlags = this->LookupFlags(
+          "CMAKE_SHARED_LIBRARY_CREATE_", llang, "_FLAGS", "-dynamiclib");
+        if (!createFlags.empty()) {
+          extraLinkOptions += " ";
+          extraLinkOptions += createFlags;
+        }
+      }
+
+      buildSettings->AddAttribute("LIBRARY_STYLE",
+                                  this->CreateString("DYNAMIC"));
+      break;
+    }
+    case cmState::EXECUTABLE: {
+      // Add the flags to create an executable.
       std::string createFlags =
-        this->LookupFlags("CMAKE_SHARED_LIBRARY_CREATE_", llang, "_FLAGS",
-                          "-dynamiclib");
-      if(!createFlags.empty())
-        {
+        this->LookupFlags("CMAKE_", llang, "_LINK_FLAGS", "");
+      if (!createFlags.empty()) {
         extraLinkOptions += " ";
         extraLinkOptions += createFlags;
-        }
-      }
-
-    buildSettings->AddAttribute("LIBRARY_STYLE",
-                                this->CreateString("DYNAMIC"));
-    break;
-    }
-    case cmState::EXECUTABLE:
-    {
-    // Add the flags to create an executable.
-    std::string createFlags =
-      this->LookupFlags("CMAKE_", llang, "_LINK_FLAGS", "");
-    if(!createFlags.empty())
-      {
-      extraLinkOptions += " ";
-      extraLinkOptions += createFlags;
       }
 
-    // Handle bundles and normal executables separately.
-    if(gtgt->GetPropertyAsBool("MACOSX_BUNDLE"))
-      {
-      std::string plist = this->ComputeInfoPListLocation(gtgt);
-      // Xcode will create the final version of Info.plist at build time,
-      // so let it replace the executable name.  This avoids creating
-      // a per-configuration Info.plist file.
-      this->CurrentLocalGenerator
-        ->GenerateAppleInfoPList(gtgt, "$(EXECUTABLE_NAME)",
-                                 plist.c_str());
-      buildSettings->AddAttribute("INFOPLIST_FILE",
-                                  this->CreateString(plist));
-
-      }
-    }
-    break;
+      // Handle bundles and normal executables separately.
+      if (gtgt->GetPropertyAsBool("MACOSX_BUNDLE")) {
+        std::string plist = this->ComputeInfoPListLocation(gtgt);
+        // Xcode will create the final version of Info.plist at build time,
+        // so let it replace the executable name.  This avoids creating
+        // a per-configuration Info.plist file.
+        this->CurrentLocalGenerator->GenerateAppleInfoPList(
+          gtgt, "$(EXECUTABLE_NAME)", plist.c_str());
+        buildSettings->AddAttribute("INFOPLIST_FILE",
+                                    this->CreateString(plist));
+      }
+    } break;
     default:
       break;
-    }
-  if(this->XcodeVersion >= 22 && this->XcodeVersion < 40)
-    {
-    buildSettings->AddAttribute("PREBINDING",
-                                this->CreateString("NO"));
-    }
+  }
+  if (this->XcodeVersion >= 22 && this->XcodeVersion < 40) {
+    buildSettings->AddAttribute("PREBINDING", this->CreateString("NO"));
+  }
 
   BuildObjectListOrString dirs(this, this->XcodeVersion >= 30);
   BuildObjectListOrString fdirs(this, this->XcodeVersion >= 30);
   std::vector<std::string> includes;
-  this->CurrentLocalGenerator->GetIncludeDirectories(includes, gtgt,
-                                                     "C", configName);
+  this->CurrentLocalGenerator->GetIncludeDirectories(includes, gtgt, "C",
+                                                     configName);
   std::set<std::string> emitted;
   emitted.insert("/System/Library/Frameworks");
-  for(std::vector<std::string>::iterator i = includes.begin();
-      i != includes.end(); ++i)
-    {
-    if(this->NameResolvesToFramework(i->c_str()))
-      {
+  for (std::vector<std::string>::iterator i = includes.begin();
+       i != includes.end(); ++i) {
+    if (this->NameResolvesToFramework(i->c_str())) {
       std::string frameworkDir = *i;
       frameworkDir += "/../";
       frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir);
-      if(emitted.insert(frameworkDir).second)
-        {
+      if (emitted.insert(frameworkDir).second) {
         fdirs.Add(this->XCodeEscapePath(frameworkDir));
-        }
       }
-    else
-      {
-      std::string incpath =
-        this->XCodeEscapePath(*i);
+    } else {
+      std::string incpath = this->XCodeEscapePath(*i);
       dirs.Add(incpath);
-      }
     }
+  }
   // Add framework search paths needed for linking.
-  if(cmComputeLinkInformation* cli = gtgt->GetLinkInformation(configName))
-    {
+  if (cmComputeLinkInformation* cli = gtgt->GetLinkInformation(configName)) {
     std::vector<std::string> const& fwDirs = cli->GetFrameworkPaths();
-    for(std::vector<std::string>::const_iterator fdi = fwDirs.begin();
-        fdi != fwDirs.end(); ++fdi)
-      {
-      if(emitted.insert(*fdi).second)
-        {
+    for (std::vector<std::string>::const_iterator fdi = fwDirs.begin();
+         fdi != fwDirs.end(); ++fdi) {
+      if (emitted.insert(*fdi).second) {
         fdirs.Add(this->XCodeEscapePath(*fdi));
-        }
       }
     }
-  if(!fdirs.IsEmpty())
-    {
-    buildSettings->AddAttribute("FRAMEWORK_SEARCH_PATHS",
-                                fdirs.CreateList());
-    }
-  if(!dirs.IsEmpty())
-    {
-    buildSettings->AddAttribute("HEADER_SEARCH_PATHS",
-                                dirs.CreateList());
-    }
+  }
+  if (!fdirs.IsEmpty()) {
+    buildSettings->AddAttribute("FRAMEWORK_SEARCH_PATHS", fdirs.CreateList());
+  }
+  if (!dirs.IsEmpty()) {
+    buildSettings->AddAttribute("HEADER_SEARCH_PATHS", dirs.CreateList());
+  }
 
   bool same_gflags = true;
   std::map<std::string, std::string> gflags;
@@ -2280,52 +1917,42 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
 
   // Minimal map of flags to build settings.
   for (std::set<std::string>::iterator li = languages.begin();
-       li != languages.end(); ++li)
-    {
+       li != languages.end(); ++li) {
     std::string& flags = cflags[*li];
     std::string& gflag = gflags[*li];
     std::string oflag =
       this->ExtractFlagRegex("(^| )(-Ofast|-Os|-O[0-9]*)( |$)", 2, flags);
-    if(oflag.size() == 2)
-      {
+    if (oflag.size() == 2) {
       optLevel = "1";
-      }
-    else if(oflag.size() > 2)
-      {
+    } else if (oflag.size() > 2) {
       optLevel = oflag.substr(2);
-      }
+    }
     gflag = this->ExtractFlag("-g", flags);
     // put back gdwarf-2 if used since there is no way
     // to represent it in the gui, but we still want debug yes
-    if(gflag == "-gdwarf-2")
-      {
+    if (gflag == "-gdwarf-2") {
       flags += " ";
       flags += gflag;
-      }
-    if (last_gflag && *last_gflag != gflag)
-      {
+    }
+    if (last_gflag && *last_gflag != gflag) {
       same_gflags = false;
-      }
-    last_gflag = &gflag;
     }
+    last_gflag = &gflag;
+  }
 
   const char* debugStr = "YES";
-  if (!same_gflags)
-    {
+  if (!same_gflags) {
     // We can't set the Xcode flag differently depending on the language,
     // so put them back in this case.
     for (std::set<std::string>::iterator li = languages.begin();
-         li != languages.end(); ++li)
-      {
+         li != languages.end(); ++li) {
       cflags[*li] += " ";
       cflags[*li] += gflags[*li];
-      }
-    debugStr = "NO";
     }
-  else if (last_gflag && (last_gflag->empty() || *last_gflag == "-g0"))
-    {
     debugStr = "NO";
-    }
+  } else if (last_gflag && (last_gflag->empty() || *last_gflag == "-g0")) {
+    debugStr = "NO";
+  }
 
   buildSettings->AddAttribute("COMBINE_HIDPI_IMAGES",
                               this->CreateString("YES"));
@@ -2338,45 +1965,40 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
   buildSettings->AddAttribute("GCC_INLINES_ARE_PRIVATE_EXTERN",
                               this->CreateString("NO"));
   for (std::set<std::string>::iterator li = languages.begin();
-       li != languages.end(); ++li)
-    {
+       li != languages.end(); ++li) {
     std::string flags = cflags[*li] + " " + defFlags;
-    if (*li == "CXX")
-      {
+    if (*li == "CXX") {
       buildSettings->AddAttribute("OTHER_CPLUSPLUSFLAGS",
                                   this->CreateString(flags));
-      }
-    else if (*li == "Fortran")
-      {
+    } else if (*li == "Fortran") {
       buildSettings->AddAttribute("IFORT_OTHER_FLAGS",
                                   this->CreateString(flags));
-      }
-    else if (*li == "C")
-      {
-      buildSettings->AddAttribute("OTHER_CFLAGS",
-                                  this->CreateString(flags));
-      }
+    } else if (*li == "C") {
+      buildSettings->AddAttribute("OTHER_CFLAGS", this->CreateString(flags));
     }
+  }
 
   // Add Fortran source format attribute if property is set.
   const char* format = 0;
   const char* tgtfmt = gtgt->GetProperty("Fortran_FORMAT");
-  switch(this->CurrentLocalGenerator->GetFortranFormat(tgtfmt))
-    {
-    case cmLocalGenerator::FortranFormatFixed: format = "fixed"; break;
-    case cmLocalGenerator::FortranFormatFree: format = "free"; break;
-    default: break;
-    }
-  if(format)
-    {
+  switch (this->CurrentLocalGenerator->GetFortranFormat(tgtfmt)) {
+    case cmLocalGenerator::FortranFormatFixed:
+      format = "fixed";
+      break;
+    case cmLocalGenerator::FortranFormatFree:
+      format = "free";
+      break;
+    default:
+      break;
+  }
+  if (format) {
     buildSettings->AddAttribute("IFORT_LANG_SRCFMT",
                                 this->CreateString(format));
-    }
+  }
 
   // Create the INSTALL_PATH attribute.
   std::string install_name_dir;
-  if(gtgt->GetType() == cmState::SHARED_LIBRARY)
-    {
+  if (gtgt->GetType() == cmState::SHARED_LIBRARY) {
     // Get the install_name directory for the build tree.
     install_name_dir = gtgt->GetInstallNameDirForBuildTree(configName);
     // Xcode doesn't create the correct install_name in some cases.
@@ -2385,86 +2007,71 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
     // This is done by adding a link flag to create an install_name
     // with just the library soname.
     std::string install_name;
-    if(!install_name_dir.empty())
-      {
+    if (!install_name_dir.empty()) {
       // Convert to a path for the native build tool.
       cmSystemTools::ConvertToUnixSlashes(install_name_dir);
       install_name += install_name_dir;
       install_name += "/";
-      }
+    }
     install_name += gtgt->GetSOName(configName);
 
-    if((realName != soName) || install_name_dir.empty())
-      {
+    if ((realName != soName) || install_name_dir.empty()) {
       install_name_dir = "";
       extraLinkOptions += " -install_name ";
       extraLinkOptions += XCodeEscapePath(install_name);
-      }
     }
+  }
   buildSettings->AddAttribute("INSTALL_PATH",
                               this->CreateString(install_name_dir));
 
   // Create the LD_RUNPATH_SEARCH_PATHS
   cmComputeLinkInformation* pcli = gtgt->GetLinkInformation(configName);
-  if(pcli)
-    {
+  if (pcli) {
     std::string search_paths;
     std::vector<std::string> runtimeDirs;
     pcli->GetRPath(runtimeDirs, false);
     // runpath dirs needs to be unique to prevent corruption
     std::set<std::string> unique_dirs;
 
-    for(std::vector<std::string>::const_iterator i = runtimeDirs.begin();
-        i != runtimeDirs.end(); ++i)
-      {
+    for (std::vector<std::string>::const_iterator i = runtimeDirs.begin();
+         i != runtimeDirs.end(); ++i) {
       std::string runpath = *i;
       runpath = this->ExpandCFGIntDir(runpath, configName);
 
-      if(unique_dirs.find(runpath) == unique_dirs.end())
-        {
+      if (unique_dirs.find(runpath) == unique_dirs.end()) {
         unique_dirs.insert(runpath);
-        if(!search_paths.empty())
-          {
+        if (!search_paths.empty()) {
           search_paths += " ";
-          }
-        search_paths += this->XCodeEscapePath(runpath);
         }
+        search_paths += this->XCodeEscapePath(runpath);
       }
-    if(!search_paths.empty())
-      {
+    }
+    if (!search_paths.empty()) {
       buildSettings->AddAttribute("LD_RUNPATH_SEARCH_PATHS",
                                   this->CreateString(search_paths));
-      }
     }
+  }
 
   buildSettings->AddAttribute(this->GetTargetLinkFlagsVar(gtgt),
                               this->CreateString(extraLinkOptions));
-  buildSettings->AddAttribute("OTHER_REZFLAGS",
-                              this->CreateString(""));
-  buildSettings->AddAttribute("SECTORDER_FLAGS",
-                              this->CreateString(""));
-  buildSettings->AddAttribute("USE_HEADERMAP",
-                              this->CreateString("NO"));
-  if (this->XcodeVersion >= 30)
-    {
-    cmXCodeObject *group = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+  buildSettings->AddAttribute("OTHER_REZFLAGS", this->CreateString(""));
+  buildSettings->AddAttribute("SECTORDER_FLAGS", this->CreateString(""));
+  buildSettings->AddAttribute("USE_HEADERMAP", this->CreateString("NO"));
+  if (this->XcodeVersion >= 30) {
+    cmXCodeObject* group = this->CreateObject(cmXCodeObject::OBJECT_LIST);
     group->AddObject(this->CreateString("-Wmost"));
     group->AddObject(this->CreateString("-Wno-four-char-constants"));
     group->AddObject(this->CreateString("-Wno-unknown-pragmas"));
     group->AddObject(this->CreateString("$(inherited)"));
     buildSettings->AddAttribute("WARNING_CFLAGS", group);
-    }
-  else
-    {
-    buildSettings->AddAttribute("WARNING_CFLAGS",
-                                this->CreateString(
-                                  "-Wmost -Wno-four-char-constants"
-                                  " -Wno-unknown-pragmas"));
-    }
+  } else {
+    buildSettings->AddAttribute(
+      "WARNING_CFLAGS", this->CreateString("-Wmost -Wno-four-char-constants"
+                                           " -Wno-unknown-pragmas"));
+  }
 
   // Runtime version information.
-  if(gtgt->GetType() == cmState::SHARED_LIBRARY)
-    {
+  if (gtgt->GetType() == cmState::SHARED_LIBRARY) {
     int major;
     int minor;
     int patch;
@@ -2474,10 +2081,9 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
     std::ostringstream v;
 
     // Xcode always wants at least 1.0.0 or nothing
-    if(!(major == 0 && minor == 0 && patch == 0))
-      {
+    if (!(major == 0 && minor == 0 && patch == 0)) {
       v << major << "." << minor << "." << patch;
-      }
+    }
     buildSettings->AddAttribute("DYLIB_CURRENT_VERSION",
                                 this->CreateString(v.str()));
 
@@ -2486,39 +2092,36 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
     std::ostringstream vso;
 
     // Xcode always wants at least 1.0.0 or nothing
-    if(!(major == 0 && minor == 0 && patch == 0))
-      {
+    if (!(major == 0 && minor == 0 && patch == 0)) {
       vso << major << "." << minor << "." << patch;
-      }
+    }
     buildSettings->AddAttribute("DYLIB_COMPATIBILITY_VERSION",
                                 this->CreateString(vso.str()));
-    }
+  }
   // put this last so it can override existing settings
   // Convert "XCODE_ATTRIBUTE_*" properties directly.
   {
-  std::vector<std::string> const& props = gtgt->GetPropertyKeys();
-  for(std::vector<std::string>::const_iterator i = props.begin();
-      i != props.end(); ++i)
-    {
-    if(i->find("XCODE_ATTRIBUTE_") == 0)
-      {
-      std::string attribute = i->substr(16);
-      this->FilterConfigurationAttribute(configName, attribute);
-      if (!attribute.empty())
-        {
-        cmGeneratorExpression ge;
-        std::string processed = ge.Parse(gtgt->GetProperty(*i))
-          ->Evaluate(this->CurrentLocalGenerator, configName);
-        buildSettings->AddAttribute(attribute.c_str(),
-                                    this->CreateString(processed));
+    std::vector<std::string> const& props = gtgt->GetPropertyKeys();
+    for (std::vector<std::string>::const_iterator i = props.begin();
+         i != props.end(); ++i) {
+      if (i->find("XCODE_ATTRIBUTE_") == 0) {
+        std::string attribute = i->substr(16);
+        this->FilterConfigurationAttribute(configName, attribute);
+        if (!attribute.empty()) {
+          cmGeneratorExpression ge;
+          std::string processed =
+            ge.Parse(gtgt->GetProperty(*i))
+              ->Evaluate(this->CurrentLocalGenerator, configName);
+          buildSettings->AddAttribute(attribute.c_str(),
+                                      this->CreateString(processed));
         }
       }
     }
   }
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateUtilityTarget(cmGeneratorTarget* gtgt)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateUtilityTarget(
+  cmGeneratorTarget* gtgt)
 {
   cmXCodeObject* shellBuildPhase =
     this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
@@ -2532,65 +2135,52 @@ cmGlobalXCodeGenerator::CreateUtilityTarget(cmGeneratorTarget* gtgt)
   shellBuildPhase->AddAttribute("outputPaths", outputPaths);
   shellBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
                                 this->CreateString("0"));
-  shellBuildPhase->AddAttribute("shellPath",
-                                this->CreateString("/bin/sh"));
-  shellBuildPhase->AddAttribute("shellScript",
-                                this->CreateString(
-                                  "# shell script goes here\nexit 0"));
-  shellBuildPhase->AddAttribute("showEnvVarsInLog",
-                                this->CreateString("0"));
+  shellBuildPhase->AddAttribute("shellPath", this->CreateString("/bin/sh"));
+  shellBuildPhase->AddAttribute(
+    "shellScript", this->CreateString("# shell script goes here\nexit 0"));
+  shellBuildPhase->AddAttribute("showEnvVarsInLog", this->CreateString("0"));
 
   cmXCodeObject* target =
     this->CreateObject(cmXCodeObject::PBXAggregateTarget);
   target->SetComment(gtgt->GetName().c_str());
-  cmXCodeObject* buildPhases =
-    this->CreateObject(cmXCodeObject::OBJECT_LIST);
+  cmXCodeObject* buildPhases = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   std::vector<cmXCodeObject*> emptyContentVector;
   this->CreateCustomCommands(buildPhases, 0, 0, 0, emptyContentVector, 0,
                              gtgt);
   target->AddAttribute("buildPhases", buildPhases);
-  if(this->XcodeVersion > 20)
-    {
+  if (this->XcodeVersion > 20) {
     this->AddConfigurations(target, gtgt);
-    }
-  else
-    {
+  } else {
     std::string theConfig =
       this->CurrentMakefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
     cmXCodeObject* buildSettings =
       this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
     this->CreateBuildSettings(gtgt, buildSettings, theConfig);
     target->AddAttribute("buildSettings", buildSettings);
-    }
-  cmXCodeObject* dependencies =
-    this->CreateObject(cmXCodeObject::OBJECT_LIST);
+  }
+  cmXCodeObject* dependencies = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   target->AddAttribute("dependencies", dependencies);
   target->AddAttribute("name", this->CreateString(gtgt->GetName()));
-  target->AddAttribute("productName",this->CreateString(gtgt->GetName()));
+  target->AddAttribute("productName", this->CreateString(gtgt->GetName()));
   target->SetTarget(gtgt);
   this->XCodeObjectMap[gtgt] = target;
 
   // Add source files without build rules for editing convenience.
-  if(gtgt->GetType() == cmState::UTILITY)
-    {
+  if (gtgt->GetType() == cmState::UTILITY) {
     std::vector<cmSourceFile*> sources;
-    if (!gtgt->GetConfigCommonSourceFiles(sources))
-      {
+    if (!gtgt->GetConfigCommonSourceFiles(sources)) {
       return 0;
-      }
+    }
 
-    for(std::vector<cmSourceFile*>::const_iterator i = sources.begin();
-        i != sources.end(); ++i)
-      {
-      if(!(*i)->GetPropertyAsBool("GENERATED"))
-        {
+    for (std::vector<cmSourceFile*>::const_iterator i = sources.begin();
+         i != sources.end(); ++i) {
+      if (!(*i)->GetPropertyAsBool("GENERATED")) {
         this->CreateXCodeFileReference(*i, gtgt);
-        }
       }
     }
+  }
 
-  target->SetId(this->GetOrCreateId(
-    gtgt->GetName(), target->GetId()).c_str());
+  target->SetId(this->GetOrCreateId(gtgt->GetName(), target->GetId()).c_str());
 
   return target;
 }
@@ -2617,50 +2207,43 @@ std::string cmGlobalXCodeGenerator::AddConfigurations(cmXCodeObject* target,
   configlist->SetComment(comment.c_str());
   target->AddAttribute("buildConfigurationList",
                        this->CreateObjectReference(configlist));
-  for(unsigned int i = 0; i < configVector.size(); ++i)
-    {
+  for (unsigned int i = 0; i < configVector.size(); ++i) {
     cmXCodeObject* config =
       this->CreateObject(cmXCodeObject::XCBuildConfiguration);
     buildConfigurations->AddObject(config);
     cmXCodeObject* buildSettings =
       this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
-    this->CreateBuildSettings(gtgt, buildSettings,
-                              configVector[i].c_str());
+    this->CreateBuildSettings(gtgt, buildSettings, configVector[i].c_str());
     config->AddAttribute("name", this->CreateString(configVector[i]));
     config->SetComment(configVector[i].c_str());
     config->AddAttribute("buildSettings", buildSettings);
-    }
-  if(!configVector.empty())
-    {
+  }
+  if (!configVector.empty()) {
     configlist->AddAttribute("defaultConfigurationName",
                              this->CreateString(configVector[0]));
     configlist->AddAttribute("defaultConfigurationIsVisible",
                              this->CreateString("0"));
     return configVector[0];
-    }
+  }
   return "";
 }
 
 const char* cmGlobalXCodeGenerator::GetTargetLinkFlagsVar(
-    cmGeneratorTarget const* target) const
+  cmGeneratorTarget const* target) const
 {
-  if(this->XcodeVersion >= 60 &&
-     (target->GetType() == cmState::STATIC_LIBRARY ||
-      target->GetType() == cmState::OBJECT_LIBRARY))
-    {
+  if (this->XcodeVersion >= 60 &&
+      (target->GetType() == cmState::STATIC_LIBRARY ||
+       target->GetType() == cmState::OBJECT_LIBRARY)) {
     return "OTHER_LIBTOOLFLAGS";
-    }
-  else
-    {
+  } else {
     return "OTHER_LDFLAGS";
-    }
+  }
 }
 
 const char* cmGlobalXCodeGenerator::GetTargetFileType(
-    cmGeneratorTarget* target)
+  cmGeneratorTarget* target)
 {
-  switch(target->GetType())
-    {
+  switch (target->GetType()) {
     case cmState::OBJECT_LIBRARY:
     case cmState::STATIC_LIBRARY:
       return "archive.ar";
@@ -2670,23 +2253,24 @@ const char* cmGlobalXCodeGenerator::GetTargetFileType(
       else if (target->IsCFBundleOnApple())
         return "wrapper.plug-in";
       else
-        return ((this->XcodeVersion >= 22)?
-              "compiled.mach-o.executable" : "compiled.mach-o.dylib");
+        return ((this->XcodeVersion >= 22) ? "compiled.mach-o.executable"
+                                           : "compiled.mach-o.dylib");
     case cmState::SHARED_LIBRARY:
-      return (target->GetPropertyAsBool("FRAMEWORK")?
-              "wrapper.framework" : "compiled.mach-o.dylib");
+      return (target->GetPropertyAsBool("FRAMEWORK")
+                ? "wrapper.framework"
+                : "compiled.mach-o.dylib");
     case cmState::EXECUTABLE:
       return "compiled.mach-o.executable";
-    default: break;
-    }
+    default:
+      break;
+  }
   return 0;
 }
 
 const char* cmGlobalXCodeGenerator::GetTargetProductType(
-    cmGeneratorTarget* target)
+  cmGeneratorTarget* target)
 {
-  switch(target->GetType())
-    {
+  switch (target->GetType()) {
     case cmState::OBJECT_LIBRARY:
     case cmState::STATIC_LIBRARY:
       return "com.apple.product-type.library.static";
@@ -2696,106 +2280,90 @@ const char* cmGlobalXCodeGenerator::GetTargetProductType(
       else if (target->IsCFBundleOnApple())
         return "com.apple.product-type.bundle";
       else
-        return ((this->XcodeVersion >= 22)?
-                "com.apple.product-type.tool" :
-                "com.apple.product-type.library.dynamic");
+        return ((this->XcodeVersion >= 22)
+                  ? "com.apple.product-type.tool"
+                  : "com.apple.product-type.library.dynamic");
     case cmState::SHARED_LIBRARY:
-      return (target->GetPropertyAsBool("FRAMEWORK")?
-              "com.apple.product-type.framework" :
-              "com.apple.product-type.library.dynamic");
+      return (target->GetPropertyAsBool("FRAMEWORK")
+                ? "com.apple.product-type.framework"
+                : "com.apple.product-type.library.dynamic");
     case cmState::EXECUTABLE:
-      return (target->GetPropertyAsBool("MACOSX_BUNDLE")?
-              "com.apple.product-type.application" :
-              "com.apple.product-type.tool");
-    default: break;
-    }
+      return (target->GetPropertyAsBool("MACOSX_BUNDLE")
+                ? "com.apple.product-type.application"
+                : "com.apple.product-type.tool");
+    default:
+      break;
+  }
   return 0;
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateXCodeTarget(cmGeneratorTarget* gtgt,
-                                          cmXCodeObject* buildPhases)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeTarget(
+  cmGeneratorTarget* gtgt, cmXCodeObject* buildPhases)
 {
-  if(gtgt->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (gtgt->GetType() == cmState::INTERFACE_LIBRARY) {
     return 0;
-    }
-  cmXCodeObject* target =
-    this->CreateObject(cmXCodeObject::PBXNativeTarget);
+  }
+  cmXCodeObject* target = this->CreateObject(cmXCodeObject::PBXNativeTarget);
   target->AddAttribute("buildPhases", buildPhases);
   cmXCodeObject* buildRules = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   target->AddAttribute("buildRules", buildRules);
   std::string defConfig;
-  if(this->XcodeVersion > 20)
-    {
+  if (this->XcodeVersion > 20) {
     defConfig = this->AddConfigurations(target, gtgt);
-    }
-  else
-    {
+  } else {
     cmXCodeObject* buildSettings =
       this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
     defConfig = this->CurrentMakefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
     this->CreateBuildSettings(gtgt, buildSettings, defConfig.c_str());
     target->AddAttribute("buildSettings", buildSettings);
-    }
-  cmXCodeObject* dependencies =
-    this->CreateObject(cmXCodeObject::OBJECT_LIST);
+  }
+  cmXCodeObject* dependencies = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   target->AddAttribute("dependencies", dependencies);
   target->AddAttribute("name", this->CreateString(gtgt->GetName()));
-  target->AddAttribute("productName",this->CreateString(gtgt->GetName()));
+  target->AddAttribute("productName", this->CreateString(gtgt->GetName()));
 
-  cmXCodeObject* fileRef =
-    this->CreateObject(cmXCodeObject::PBXFileReference);
-  if(const char* fileType = this->GetTargetFileType(gtgt))
-    {
+  cmXCodeObject* fileRef = this->CreateObject(cmXCodeObject::PBXFileReference);
+  if (const char* fileType = this->GetTargetFileType(gtgt)) {
     fileRef->AddAttribute("explicitFileType", this->CreateString(fileType));
-    }
+  }
   std::string fullName;
-  if(gtgt->GetType() == cmState::OBJECT_LIBRARY)
-    {
+  if (gtgt->GetType() == cmState::OBJECT_LIBRARY) {
     fullName = "lib";
     fullName += gtgt->GetName();
     fullName += ".a";
-    }
-  else
-    {
+  } else {
     fullName = gtgt->GetFullName(defConfig.c_str());
-    }
+  }
   fileRef->AddAttribute("path", this->CreateString(fullName));
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     fileRef->AddAttribute("refType", this->CreateString("0"));
-    }
+  }
   fileRef->AddAttribute("sourceTree",
                         this->CreateString("BUILT_PRODUCTS_DIR"));
   fileRef->SetComment(gtgt->GetName().c_str());
   target->AddAttribute("productReference",
                        this->CreateObjectReference(fileRef));
-  if(const char* productType = this->GetTargetProductType(gtgt))
-    {
+  if (const char* productType = this->GetTargetProductType(gtgt)) {
     target->AddAttribute("productType", this->CreateString(productType));
-    }
+  }
   target->SetTarget(gtgt);
   this->XCodeObjectMap[gtgt] = target;
-  target->SetId(this->GetOrCreateId(
-    gtgt->GetName(), target->GetId()).c_str());
+  target->SetId(this->GetOrCreateId(gtgt->GetName(), target->GetId()).c_str());
   return target;
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::FindXCodeTarget(cmGeneratorTarget const* t)
+cmXCodeObject* cmGlobalXCodeGenerator::FindXCodeTarget(
+  cmGeneratorTarget const* t)
 {
-  if(!t)
-    {
+  if (!t) {
     return 0;
-    }
+  }
 
   std::map<cmGeneratorTarget const*, cmXCodeObject*>::const_iterator const i =
     this->XCodeObjectMap.find(t);
-  if (i == this->XCodeObjectMap.end())
-    {
+  if (i == this->XCodeObjectMap.end()) {
     return 0;
-    }
+  }
   return i->second;
 }
 
@@ -2807,13 +2375,13 @@ std::string cmGlobalXCodeGenerator::GetOrCreateId(const std::string& name,
   const char* storedGUID =
     this->CMakeInstance->GetCacheDefinition(guidStoreName.c_str());
 
-  if(storedGUID)
-    {
+  if (storedGUID) {
     return storedGUID;
-    }
+  }
 
-  this->CMakeInstance->AddCacheEntry(guidStoreName.c_str(),
-    id.c_str(), "Stored Xcode object GUID", cmState::INTERNAL);
+  this->CMakeInstance->AddCacheEntry(guidStoreName.c_str(), id.c_str(),
+                                     "Stored Xcode object GUID",
+                                     cmState::INTERNAL);
 
   return id;
 }
@@ -2830,66 +2398,52 @@ void cmGlobalXCodeGenerator::AddDependTarget(cmXCodeObject* target,
   container->AddAttribute("proxyType", this->CreateString("1"));
   container->AddAttribute("remoteGlobalIDString",
                           this->CreateObjectReference(dependTarget));
-  container->AddAttribute("remoteInfo",
-                          this->CreateString(
-                            dependTarget->GetTarget()->GetName()));
+  container->AddAttribute(
+    "remoteInfo", this->CreateString(dependTarget->GetTarget()->GetName()));
   cmXCodeObject* targetdep =
     this->CreateObject(cmXCodeObject::PBXTargetDependency);
   targetdep->SetComment("PBXTargetDependency");
-  targetdep->AddAttribute("target",
-                          this->CreateObjectReference(dependTarget));
+  targetdep->AddAttribute("target", this->CreateObjectReference(dependTarget));
   targetdep->AddAttribute("targetProxy",
                           this->CreateObjectReference(container));
 
   cmXCodeObject* depends = target->GetObject("dependencies");
-  if(!depends)
-    {
-    cmSystemTools::
-      Error("target does not have dependencies attribute error..");
+  if (!depends) {
+    cmSystemTools::Error(
+      "target does not have dependencies attribute error..");
 
-    }
-  else
-    {
+  } else {
     depends->AddUniqueObject(targetdep);
-    }
+  }
 }
 
 void cmGlobalXCodeGenerator::AppendOrAddBuildSetting(cmXCodeObject* settings,
                                                      const char* attribute,
                                                      const char* value)
 {
-  if(settings)
-    {
+  if (settings) {
     cmXCodeObject* attr = settings->GetObject(attribute);
-    if(!attr)
-      {
+    if (!attr) {
       settings->AddAttribute(attribute, this->CreateString(value));
-      }
-    else
-      {
+    } else {
       std::string oldValue = attr->GetString();
       oldValue += " ";
       oldValue += value;
       attr->SetString(oldValue.c_str());
-      }
     }
+  }
 }
 
-void cmGlobalXCodeGenerator
-::AppendBuildSettingAttribute(cmXCodeObject* target,
-                              const char* attribute,
-                              const char* value,
-                              const std::string& configName)
+void cmGlobalXCodeGenerator::AppendBuildSettingAttribute(
+  cmXCodeObject* target, const char* attribute, const char* value,
+  const std::string& configName)
 {
-  if(this->XcodeVersion < 21)
-    {
+  if (this->XcodeVersion < 21) {
     // There is only one configuration.  Add the setting to the buildSettings
     // of the target.
     this->AppendOrAddBuildSetting(target->GetObject("buildSettings"),
                                   attribute, value);
-    }
-  else
-    {
+  } else {
     // There are multiple configurations.  Add the setting to the
     // buildSettings of the configuration name given.
     cmXCodeObject* configurationList =
@@ -2898,360 +2452,307 @@ void cmGlobalXCodeGenerator
       configurationList->GetObject("buildConfigurations");
     std::vector<cmXCodeObject*> list = buildConfigs->GetObjectList();
     // each configuration and the target itself has a buildSettings in it
-    //list.push_back(target);
-    for(std::vector<cmXCodeObject*>::iterator i = list.begin();
-        i != list.end(); ++i)
-      {
-      if(!configName.empty())
-        {
-        if((*i)->GetObject("name")->GetString() == configName)
-          {
+    // list.push_back(target);
+    for (std::vector<cmXCodeObject*>::iterator i = list.begin();
+         i != list.end(); ++i) {
+      if (!configName.empty()) {
+        if ((*i)->GetObject("name")->GetString() == configName) {
           cmXCodeObject* settings = (*i)->GetObject("buildSettings");
           this->AppendOrAddBuildSetting(settings, attribute, value);
-          }
         }
-      else
-        {
+      } else {
         cmXCodeObject* settings = (*i)->GetObject("buildSettings");
         this->AppendOrAddBuildSetting(settings, attribute, value);
-        }
       }
     }
+  }
 }
 
-void cmGlobalXCodeGenerator
-::AddDependAndLinkInformation(cmXCodeObject* target)
+void cmGlobalXCodeGenerator::AddDependAndLinkInformation(cmXCodeObject* target)
 {
   cmGeneratorTarget* gt = target->GetTarget();
-  if(!gt)
-    {
+  if (!gt) {
     cmSystemTools::Error("Error no target on xobject\n");
     return;
-    }
-  if(gt->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  }
+  if (gt->GetType() == cmState::INTERFACE_LIBRARY) {
     return;
-    }
+  }
 
   // Add dependencies on other CMake targets.
   TargetDependSet const& deps = this->GetTargetDirectDepends(gt);
-  for(TargetDependSet::const_iterator i = deps.begin(); i != deps.end(); ++i)
-    {
-    if(cmXCodeObject* dptarget = this->FindXCodeTarget(*i))
-      {
+  for (TargetDependSet::const_iterator i = deps.begin(); i != deps.end();
+       ++i) {
+    if (cmXCodeObject* dptarget = this->FindXCodeTarget(*i)) {
       this->AddDependTarget(target, dptarget);
-      }
     }
+  }
 
   // Loop over configuration types and set per-configuration info.
-  for(std::vector<std::string>::iterator i =
-        this->CurrentConfigurationTypes.begin();
-      i != this->CurrentConfigurationTypes.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i =
+         this->CurrentConfigurationTypes.begin();
+       i != this->CurrentConfigurationTypes.end(); ++i) {
     // Get the current configuration name.
     std::string configName = *i;
 
-    if(this->XcodeVersion >= 50)
-      {
+    if (this->XcodeVersion >= 50) {
       // Add object library contents as link flags.
       std::string linkObjs;
       const char* sep = "";
       std::vector<std::string> objs;
       gt->UseObjectLibraries(objs, "");
-      for(std::vector<std::string>::const_iterator
-            oi = objs.begin(); oi != objs.end(); ++oi)
-        {
+      for (std::vector<std::string>::const_iterator oi = objs.begin();
+           oi != objs.end(); ++oi) {
         linkObjs += sep;
         sep = " ";
         linkObjs += this->XCodeEscapePath(*oi);
-        }
-      this->AppendBuildSettingAttribute(
-        target, this->GetTargetLinkFlagsVar(gt),
-        linkObjs.c_str(), configName);
       }
+      this->AppendBuildSettingAttribute(
+        target, this->GetTargetLinkFlagsVar(gt), linkObjs.c_str(), configName);
+    }
 
     // Skip link information for object libraries.
-    if(gt->GetType() == cmState::OBJECT_LIBRARY ||
-       gt->GetType() == cmState::STATIC_LIBRARY)
-      {
+    if (gt->GetType() == cmState::OBJECT_LIBRARY ||
+        gt->GetType() == cmState::STATIC_LIBRARY) {
       continue;
-      }
+    }
 
     // Compute the link library and directory information.
     cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName);
-    if(!pcli)
-      {
+    if (!pcli) {
       continue;
-      }
+    }
     cmComputeLinkInformation& cli = *pcli;
 
     // Add dependencies directly on library files.
     {
-    std::vector<std::string> const& libDeps = cli.GetDepends();
-    for(std::vector<std::string>::const_iterator j = libDeps.begin();
-        j != libDeps.end(); ++j)
-      {
-      target->AddDependLibrary(configName, j->c_str());
+      std::vector<std::string> const& libDeps = cli.GetDepends();
+      for (std::vector<std::string>::const_iterator j = libDeps.begin();
+           j != libDeps.end(); ++j) {
+        target->AddDependLibrary(configName, j->c_str());
       }
     }
 
     // add the library search paths
     {
-    std::vector<std::string> const& libDirs = cli.GetDirectories();
-    std::string linkDirs;
-    for(std::vector<std::string>::const_iterator libDir = libDirs.begin();
-        libDir != libDirs.end(); ++libDir)
-      {
-      if(libDir->size() && *libDir != "/usr/lib")
-        {
-        if(this->XcodeVersion > 15)
-          {
-          // Now add the same one but append
-          // $(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME) to it:
-          linkDirs += " ";
-          linkDirs += this->XCodeEscapePath(
-            *libDir + "/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)");
+      std::vector<std::string> const& libDirs = cli.GetDirectories();
+      std::string linkDirs;
+      for (std::vector<std::string>::const_iterator libDir = libDirs.begin();
+           libDir != libDirs.end(); ++libDir) {
+        if (libDir->size() && *libDir != "/usr/lib") {
+          if (this->XcodeVersion > 15) {
+            // Now add the same one but append
+            // $(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME) to it:
+            linkDirs += " ";
+            linkDirs += this->XCodeEscapePath(
+              *libDir + "/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)");
           }
-        linkDirs += " ";
-        linkDirs += this->XCodeEscapePath(*libDir);
+          linkDirs += " ";
+          linkDirs += this->XCodeEscapePath(*libDir);
         }
       }
-    this->AppendBuildSettingAttribute(target, "LIBRARY_SEARCH_PATHS",
-                                      linkDirs.c_str(), configName);
+      this->AppendBuildSettingAttribute(target, "LIBRARY_SEARCH_PATHS",
+                                        linkDirs.c_str(), configName);
     }
 
     // now add the link libraries
     {
-    std::string linkLibs;
-    const char* sep = "";
-    typedef cmComputeLinkInformation::ItemVector ItemVector;
-    ItemVector const& libNames = cli.GetItems();
-    for(ItemVector::const_iterator li = libNames.begin();
-        li != libNames.end(); ++li)
-      {
-      linkLibs += sep;
-      sep = " ";
-      if(li->IsPath)
-        {
-        linkLibs += this->XCodeEscapePath(li->Value);
-        }
-      else if (!li->Target
-          || li->Target->GetType() != cmState::INTERFACE_LIBRARY)
-        {
-        linkLibs += li->Value;
+      std::string linkLibs;
+      const char* sep = "";
+      typedef cmComputeLinkInformation::ItemVector ItemVector;
+      ItemVector const& libNames = cli.GetItems();
+      for (ItemVector::const_iterator li = libNames.begin();
+           li != libNames.end(); ++li) {
+        linkLibs += sep;
+        sep = " ";
+        if (li->IsPath) {
+          linkLibs += this->XCodeEscapePath(li->Value);
+        } else if (!li->Target ||
+                   li->Target->GetType() != cmState::INTERFACE_LIBRARY) {
+          linkLibs += li->Value;
         }
-      if(li->Target && !li->Target->IsImported())
-        {
-        target->AddDependTarget(configName, li->Target->GetName());
+        if (li->Target && !li->Target->IsImported()) {
+          target->AddDependTarget(configName, li->Target->GetName());
         }
       }
-    this->AppendBuildSettingAttribute(
-      target, this->GetTargetLinkFlagsVar(gt),
-      linkLibs.c_str(), configName);
-    }
+      this->AppendBuildSettingAttribute(
+        target, this->GetTargetLinkFlagsVar(gt), linkLibs.c_str(), configName);
     }
+  }
 }
 
-bool cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root,
-                                          std::vector<cmLocalGenerator*>&
-                                          generators)
+bool cmGlobalXCodeGenerator::CreateGroups(
+  cmLocalGenerator* root, std::vector<cmLocalGenerator*>& generators)
 {
-  for(std::vector<cmLocalGenerator*>::iterator i = generators.begin();
-      i != generators.end(); ++i)
-    {
-    if(this->IsExcluded(root, *i))
-      {
+  for (std::vector<cmLocalGenerator*>::iterator i = generators.begin();
+       i != generators.end(); ++i) {
+    if (this->IsExcluded(root, *i)) {
       continue;
-      }
+    }
     cmMakefile* mf = (*i)->GetMakefile();
     std::vector<cmSourceGroup> sourceGroups = mf->GetSourceGroups();
     std::vector<cmGeneratorTarget*> tgts = (*i)->GetGeneratorTargets();
-    for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-        l != tgts.end(); l++)
-      {
+    for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
+         l != tgts.end(); l++) {
       cmGeneratorTarget* gtgt = *l;
 
       // Same skipping logic here as in CreateXCodeTargets so that we do not
       // end up with (empty anyhow) ALL_BUILD and XCODE_DEPEND_HELPER source
       // groups:
       //
-      if(gtgt->GetType() == cmState::GLOBAL_TARGET)
-        {
+      if (gtgt->GetType() == cmState::GLOBAL_TARGET) {
         continue;
-        }
-      if(gtgt->GetType() == cmState::INTERFACE_LIBRARY)
-        {
+      }
+      if (gtgt->GetType() == cmState::INTERFACE_LIBRARY) {
         continue;
-        }
+      }
 
       // add the soon to be generated Info.plist file as a source for a
       // MACOSX_BUNDLE file
-      if(gtgt->GetPropertyAsBool("MACOSX_BUNDLE"))
-        {
+      if (gtgt->GetPropertyAsBool("MACOSX_BUNDLE")) {
         std::string plist = this->ComputeInfoPListLocation(gtgt);
         mf->GetOrCreateSource(plist, true);
         gtgt->AddSource(plist);
-        }
+      }
 
       std::vector<cmSourceFile*> classes;
-      if (!gtgt->GetConfigCommonSourceFiles(classes))
-        {
+      if (!gtgt->GetConfigCommonSourceFiles(classes)) {
         return false;
-        }
+      }
       // Put cmSourceFile instances in proper groups:
-      for(std::vector<cmSourceFile*>::const_iterator s = classes.begin();
-          s != classes.end(); s++)
-        {
+      for (std::vector<cmSourceFile*>::const_iterator s = classes.begin();
+           s != classes.end(); s++) {
         cmSourceFile* sf = *s;
         // Add the file to the list of sources.
         std::string const& source = sf->GetFullPath();
         cmSourceGroup* sourceGroup =
           mf->FindSourceGroup(source.c_str(), sourceGroups);
-        cmXCodeObject* pbxgroup =
-          this->CreateOrGetPBXGroup(gtgt, sourceGroup);
+        cmXCodeObject* pbxgroup = this->CreateOrGetPBXGroup(gtgt, sourceGroup);
         std::string key = GetGroupMapKey(gtgt, sf);
         this->GroupMap[key] = pbxgroup;
-        }
+      }
 
       // Put OBJECT_LIBRARY objects in proper groups:
       std::vector<std::string> objs;
       gtgt->UseObjectLibraries(objs, "");
-      for(std::vector<std::string>::const_iterator
-            oi = objs.begin(); oi != objs.end(); ++oi)
-        {
+      for (std::vector<std::string>::const_iterator oi = objs.begin();
+           oi != objs.end(); ++oi) {
         std::string const& source = *oi;
         cmSourceGroup* sourceGroup =
           mf->FindSourceGroup(source.c_str(), sourceGroups);
-        cmXCodeObject* pbxgroup =
-          this->CreateOrGetPBXGroup(gtgt, sourceGroup);
+        cmXCodeObject* pbxgroup = this->CreateOrGetPBXGroup(gtgt, sourceGroup);
         std::string key = GetGroupMapKeyFromPath(gtgt, source);
         this->GroupMap[key] = pbxgroup;
-        }
       }
     }
+  }
   return true;
 }
 
-cmXCodeObject *cmGlobalXCodeGenerator
-::CreatePBXGroup(cmXCodeObject *parent, std::string name)
+cmXCodeObject* cmGlobalXCodeGenerator::CreatePBXGroup(cmXCodeObject* parent,
+                                                      std::string name)
 {
   cmXCodeObject* parentChildren = NULL;
-  if(parent)
+  if (parent)
     parentChildren = parent->GetObject("children");
   cmXCodeObject* group = this->CreateObject(cmXCodeObject::PBXGroup);
   cmXCodeObject* groupChildren =
-  this->CreateObject(cmXCodeObject::OBJECT_LIST);
+    this->CreateObject(cmXCodeObject::OBJECT_LIST);
   group->AddAttribute("name", this->CreateString(name));
   group->AddAttribute("children", groupChildren);
-  if(this->XcodeVersion == 15)
-  {
+  if (this->XcodeVersion == 15) {
     group->AddAttribute("refType", this->CreateString("4"));
   }
   group->AddAttribute("sourceTree", this->CreateString("<group>"));
-  if(parentChildren)
+  if (parentChildren)
     parentChildren->AddObject(group);
   return group;
 }
 
-cmXCodeObject* cmGlobalXCodeGenerator
-::CreateOrGetPBXGroup(cmGeneratorTarget* gtgt, cmSourceGroup* sg)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateOrGetPBXGroup(
+  cmGeneratorTarget* gtgt, cmSourceGroup* sg)
 {
   std::string s;
   std::string target;
-  const char *targetFolder= gtgt->GetProperty("FOLDER");
-  if(targetFolder) {
+  const char* targetFolder = gtgt->GetProperty("FOLDER");
+  if (targetFolder) {
     target = targetFolder;
     target += "/";
   }
   target += gtgt->GetName();
   s = target + "/";
   s += sg->GetFullName();
-  std::map<std::string, cmXCodeObject* >::iterator it =
+  std::map<std::string, cmXCodeObject*>::iterator it =
     this->GroupNameMap.find(s);
-  if(it != this->GroupNameMap.end())
-    {
+  if (it != this->GroupNameMap.end()) {
     return it->second;
-    }
+  }
 
   it = this->TargetGroup.find(target);
   cmXCodeObject* tgroup = 0;
-  if(it != this->TargetGroup.end())
-    {
+  if (it != this->TargetGroup.end()) {
     tgroup = it->second;
-    }
-  else
-    {
+  } else {
     std::vector<std::string> tgt_folders =
       cmSystemTools::tokenize(target, "/");
     std::string curr_tgt_folder;
-    for(std::vector<std::string>::size_type i = 0; i < tgt_folders.size();i++)
-      {
-      if (i != 0)
-        {
+    for (std::vector<std::string>::size_type i = 0; i < tgt_folders.size();
+         i++) {
+      if (i != 0) {
         curr_tgt_folder += "/";
-        }
+      }
       curr_tgt_folder += tgt_folders[i];
       it = this->TargetGroup.find(curr_tgt_folder);
-      if(it != this->TargetGroup.end())
-        {
+      if (it != this->TargetGroup.end()) {
         tgroup = it->second;
         continue;
-        }
-      tgroup = this->CreatePBXGroup(tgroup,tgt_folders[i]);
+      }
+      tgroup = this->CreatePBXGroup(tgroup, tgt_folders[i]);
       this->TargetGroup[curr_tgt_folder] = tgroup;
-      if(i == 0)
-        {
+      if (i == 0) {
         this->SourcesGroupChildren->AddObject(tgroup);
-        }
       }
     }
+  }
   this->TargetGroup[target] = tgroup;
 
   // If it's the default source group (empty name) then put the source file
   // directly in the tgroup...
   //
-  if (std::string(sg->GetFullName()) == "")
-    {
+  if (std::string(sg->GetFullName()) == "") {
     this->GroupNameMap[s] = tgroup;
     return tgroup;
-    }
+  }
 
-  //It's a recursive folder structure, let's find the real parent group
-  if(std::string(sg->GetFullName()) != std::string(sg->GetName()))
-    {
+  // It's a recursive folder structure, let's find the real parent group
+  if (std::string(sg->GetFullName()) != std::string(sg->GetName())) {
     std::vector<std::string> folders =
       cmSystemTools::tokenize(sg->GetFullName(), "\\");
     std::string curr_folder = target;
     curr_folder += "/";
-    for(std::vector<std::string>::size_type i = 0; i < folders.size();i++)
-      {
+    for (std::vector<std::string>::size_type i = 0; i < folders.size(); i++) {
       curr_folder += folders[i];
-      std::map<std::string, cmXCodeObject* >::iterator i_folder =
+      std::map<std::string, cmXCodeObject*>::iterator i_folder =
         this->GroupNameMap.find(curr_folder);
-      //Create new folder
-      if(i_folder == this->GroupNameMap.end())
-        {
-        cmXCodeObject *group = this->CreatePBXGroup(tgroup,folders[i]);
+      // Create new folder
+      if (i_folder == this->GroupNameMap.end()) {
+        cmXCodeObject* group = this->CreatePBXGroup(tgroup, folders[i]);
         this->GroupNameMap[curr_folder] = group;
         tgroup = group;
-        }
-      else
-        {
+      } else {
         tgroup = i_folder->second;
-        }
-      curr_folder = curr_folder + "\\";
       }
-    return tgroup;
+      curr_folder = curr_folder + "\\";
     }
-  cmXCodeObject *group = this->CreatePBXGroup(tgroup,sg->GetName());
+    return tgroup;
+  }
+  cmXCodeObject* group = this->CreatePBXGroup(tgroup, sg->GetName());
   this->GroupNameMap[s] = group;
   return group;
 }
 
-bool cmGlobalXCodeGenerator
-::CreateXCodeObjects(cmLocalGenerator* root,
-                     std::vector<cmLocalGenerator*>&
-                     generators)
+bool cmGlobalXCodeGenerator::CreateXCodeObjects(
+  cmLocalGenerator* root, std::vector<cmLocalGenerator*>& generators)
 {
   this->ClearXCodeObjects();
   this->RootObject = 0;
@@ -3263,24 +2764,19 @@ bool cmGlobalXCodeGenerator
   cmXCodeObject* developBuildStyle =
     this->CreateObject(cmXCodeObject::PBXBuildStyle);
   cmXCodeObject* listObjs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
-  if(this->XcodeVersion == 15)
-    {
-    developBuildStyle->AddAttribute("name",
-                                    this->CreateString("Development"));
+  if (this->XcodeVersion == 15) {
+    developBuildStyle->AddAttribute("name", this->CreateString("Development"));
     developBuildStyle->AddAttribute("buildSettings", group);
     listObjs->AddObject(developBuildStyle);
     group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
     group->AddAttribute("COPY_PHASE_STRIP", this->CreateString("YES"));
     cmXCodeObject* deployBuildStyle =
-    this->CreateObject(cmXCodeObject::PBXBuildStyle);
+      this->CreateObject(cmXCodeObject::PBXBuildStyle);
     deployBuildStyle->AddAttribute("name", this->CreateString("Deployment"));
     deployBuildStyle->AddAttribute("buildSettings", group);
     listObjs->AddObject(deployBuildStyle);
-    }
-  else
-    {
-    for(unsigned int i = 0; i < this->CurrentConfigurationTypes.size(); ++i)
-      {
+  } else {
+    for (unsigned int i = 0; i < this->CurrentConfigurationTypes.size(); ++i) {
       cmXCodeObject* buildStyle =
         this->CreateObject(cmXCodeObject::PBXBuildStyle);
       const char* name = this->CurrentConfigurationTypes[i].c_str();
@@ -3291,28 +2787,24 @@ bool cmGlobalXCodeGenerator
       sgroup->AddAttribute("COPY_PHASE_STRIP", this->CreateString("NO"));
       buildStyle->AddAttribute("buildSettings", sgroup);
       listObjs->AddObject(buildStyle);
-      }
     }
+  }
 
   cmXCodeObject* mainGroup = this->CreateObject(cmXCodeObject::PBXGroup);
-  this->MainGroupChildren =
-    this->CreateObject(cmXCodeObject::OBJECT_LIST);
+  this->MainGroupChildren = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   mainGroup->AddAttribute("children", this->MainGroupChildren);
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     mainGroup->AddAttribute("refType", this->CreateString("4"));
-    }
+  }
   mainGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
 
   cmXCodeObject* sourcesGroup = this->CreateObject(cmXCodeObject::PBXGroup);
-  this->SourcesGroupChildren =
-    this->CreateObject(cmXCodeObject::OBJECT_LIST);
+  this->SourcesGroupChildren = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   sourcesGroup->AddAttribute("name", this->CreateString("Sources"));
   sourcesGroup->AddAttribute("children", this->SourcesGroupChildren);
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     sourcesGroup->AddAttribute("refType", this->CreateString("4"));
-    }
+  }
   sourcesGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
   this->MainGroupChildren->AddObject(sourcesGroup);
 
@@ -3321,49 +2813,45 @@ bool cmGlobalXCodeGenerator
     this->CreateObject(cmXCodeObject::OBJECT_LIST);
   resourcesGroup->AddAttribute("name", this->CreateString("Resources"));
   resourcesGroup->AddAttribute("children", this->ResourcesGroupChildren);
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     resourcesGroup->AddAttribute("refType", this->CreateString("4"));
-    }
+  }
   resourcesGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
   this->MainGroupChildren->AddObject(resourcesGroup);
 
   // now create the cmake groups
-  if (!this->CreateGroups(root, generators))
-    {
+  if (!this->CreateGroups(root, generators)) {
     return false;
-    }
+  }
 
   cmXCodeObject* productGroup = this->CreateObject(cmXCodeObject::PBXGroup);
   productGroup->AddAttribute("name", this->CreateString("Products"));
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     productGroup->AddAttribute("refType", this->CreateString("4"));
-    }
+  }
   productGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
   cmXCodeObject* productGroupChildren =
     this->CreateObject(cmXCodeObject::OBJECT_LIST);
   productGroup->AddAttribute("children", productGroupChildren);
   this->MainGroupChildren->AddObject(productGroup);
 
-
   this->RootObject = this->CreateObject(cmXCodeObject::PBXProject);
   this->RootObject->SetComment("Project object");
 
   std::string project_id = "PROJECT_";
   project_id += root->GetProjectName();
-  this->RootObject->SetId(this->GetOrCreateId(
-    project_id.c_str(), this->RootObject->GetId()).c_str());
+  this->RootObject->SetId(
+    this->GetOrCreateId(project_id.c_str(), this->RootObject->GetId())
+      .c_str());
 
   group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
   this->RootObject->AddAttribute("mainGroup",
-                             this->CreateObjectReference(mainGroup));
+                                 this->CreateObjectReference(mainGroup));
   this->RootObject->AddAttribute("buildSettings", group);
   this->RootObject->AddAttribute("buildStyles", listObjs);
   this->RootObject->AddAttribute("hasScannedForEncodings",
-                             this->CreateString("0"));
-  if (this->XcodeVersion >= 30)
-    {
+                                 this->CreateString("0"));
+  if (this->XcodeVersion >= 30) {
     group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
     group->AddAttribute("BuildIndependentTargetsInParallel",
                         this->CreateString("YES"));
@@ -3380,14 +2868,13 @@ bool cmGlobalXCodeGenerator
     else
       this->RootObject->AddAttribute("compatibilityVersion",
                                      this->CreateString("Xcode 3.0"));
-    }
+  }
   // Point Xcode at the top of the source tree.
   {
-  std::string pdir =
-    this->RelativeToBinary(root->GetCurrentSourceDirectory());
-  this->RootObject->AddAttribute("projectDirPath",
-                                 this->CreateString(pdir));
-  this->RootObject->AddAttribute("projectRoot", this->CreateString(""));
+    std::string pdir =
+      this->RelativeToBinary(root->GetCurrentSourceDirectory());
+    this->RootObject->AddAttribute("projectDirPath", this->CreateString(pdir));
+    this->RootObject->AddAttribute("projectRoot", this->CreateString(""));
   }
   cmXCodeObject* configlist =
     this->CreateObject(cmXCodeObject::XCConfigurationList);
@@ -3395,9 +2882,8 @@ bool cmGlobalXCodeGenerator
     this->CreateObject(cmXCodeObject::OBJECT_LIST);
   typedef std::vector<std::pair<std::string, cmXCodeObject*> > Configs;
   Configs configs;
-  const char *defaultConfigName = "Debug";
-  if(this->XcodeVersion == 15)
-    {
+  const char* defaultConfigName = "Debug";
+  if (this->XcodeVersion == 15) {
     cmXCodeObject* configDebug =
       this->CreateObject(cmXCodeObject::XCBuildConfiguration);
     configDebug->AddAttribute("name", this->CreateString("Debug"));
@@ -3406,26 +2892,21 @@ bool cmGlobalXCodeGenerator
       this->CreateObject(cmXCodeObject::XCBuildConfiguration);
     configRelease->AddAttribute("name", this->CreateString("Release"));
     configs.push_back(std::make_pair("Release", configRelease));
-    }
-  else
-    {
-    for(unsigned int i = 0; i < this->CurrentConfigurationTypes.size(); ++i)
-      {
+  } else {
+    for (unsigned int i = 0; i < this->CurrentConfigurationTypes.size(); ++i) {
       const char* name = this->CurrentConfigurationTypes[i].c_str();
-      if (0 == i)
-        {
+      if (0 == i) {
         defaultConfigName = name;
-        }
+      }
       cmXCodeObject* config =
         this->CreateObject(cmXCodeObject::XCBuildConfiguration);
       config->AddAttribute("name", this->CreateString(name));
       configs.push_back(std::make_pair(name, config));
-      }
     }
-  for(Configs::iterator c = configs.begin(); c != configs.end(); ++c)
-    {
+  }
+  for (Configs::iterator c = configs.begin(); c != configs.end(); ++c) {
     buildConfigurations->AddObject(c->second);
-    }
+  }
   configlist->AddAttribute("buildConfigurations", buildConfigurations);
 
   std::string comment = "Build configuration list for PBXProject";
@@ -3438,133 +2919,111 @@ bool cmGlobalXCodeGenerator
   configlist->AddAttribute("defaultConfigurationName",
                            this->CreateString(defaultConfigName));
   cmXCodeObject* buildSettings =
-      this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
+    this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
   const char* osxArch =
-      this->CurrentMakefile->GetDefinition("CMAKE_OSX_ARCHITECTURES");
+    this->CurrentMakefile->GetDefinition("CMAKE_OSX_ARCHITECTURES");
   const char* sysroot =
-      this->CurrentMakefile->GetDefinition("CMAKE_OSX_SYSROOT");
+    this->CurrentMakefile->GetDefinition("CMAKE_OSX_SYSROOT");
   const char* deploymentTarget =
     this->CurrentMakefile->GetDefinition("CMAKE_OSX_DEPLOYMENT_TARGET");
   std::string archs;
-  if(sysroot)
-    {
-    if(osxArch)
-      {
+  if (sysroot) {
+    if (osxArch) {
       // recompute this as it may have been changed since enable language
       this->Architectures.clear();
       cmSystemTools::ExpandListArgument(std::string(osxArch),
                                         this->Architectures);
       archs = cmJoin(this->Architectures, " ");
-      }
-    buildSettings->AddAttribute("SDKROOT",
-                                this->CreateString(sysroot));
     }
-  if (archs.empty())
-    {
+    buildSettings->AddAttribute("SDKROOT", this->CreateString(sysroot));
+  }
+  if (archs.empty()) {
     // Tell Xcode to use NATIVE_ARCH instead of ARCHS.
     buildSettings->AddAttribute("ONLY_ACTIVE_ARCH", this->CreateString("YES"));
-    }
-  else
-    {
+  } else {
     // Tell Xcode to use ARCHS (ONLY_ACTIVE_ARCH defaults to NO).
     buildSettings->AddAttribute("ARCHS", this->CreateString(archs));
-    }
-  if(deploymentTarget && *deploymentTarget)
-    {
+  }
+  if (deploymentTarget && *deploymentTarget) {
     buildSettings->AddAttribute("MACOSX_DEPLOYMENT_TARGET",
                                 this->CreateString(deploymentTarget));
-    }
-  if(!this->GeneratorToolset.empty())
-    {
+  }
+  if (!this->GeneratorToolset.empty()) {
     buildSettings->AddAttribute("GCC_VERSION",
-      this->CreateString(this->GeneratorToolset));
-    }
+                                this->CreateString(this->GeneratorToolset));
+  }
 
   std::string symroot = root->GetCurrentBinaryDirectory();
   symroot += "/build";
   buildSettings->AddAttribute("SYMROOT", this->CreateString(symroot));
 
-  for(Configs::iterator i = configs.begin(); i != configs.end(); ++i)
-    {
+  for (Configs::iterator i = configs.begin(); i != configs.end(); ++i) {
     cmXCodeObject* buildSettingsForCfg = this->CreateFlatClone(buildSettings);
 
     // Put this last so it can override existing settings
     // Convert "CMAKE_XCODE_ATTRIBUTE_*" variables directly.
     std::vector<std::string> vars = this->CurrentMakefile->GetDefinitions();
-    for(std::vector<std::string>::const_iterator d = vars.begin();
-        d != vars.end(); ++d)
-      {
-      if(d->find("CMAKE_XCODE_ATTRIBUTE_") == 0)
-        {
+    for (std::vector<std::string>::const_iterator d = vars.begin();
+         d != vars.end(); ++d) {
+      if (d->find("CMAKE_XCODE_ATTRIBUTE_") == 0) {
         std::string attribute = d->substr(22);
         this->FilterConfigurationAttribute(i->first, attribute);
-        if(!attribute.empty())
-          {
+        if (!attribute.empty()) {
           cmGeneratorExpression ge;
           std::string processed =
             ge.Parse(this->CurrentMakefile->GetDefinition(*d))
               ->Evaluate(this->CurrentLocalGenerator, i->first);
           buildSettingsForCfg->AddAttribute(attribute,
-            this->CreateString(processed));
-          }
+                                            this->CreateString(processed));
         }
       }
+    }
     // store per-config buildSettings into configuration object
     i->second->AddAttribute("buildSettings", buildSettingsForCfg);
-    }
+  }
 
   this->RootObject->AddAttribute("buildConfigurationList",
-                             this->CreateObjectReference(configlist));
+                                 this->CreateObjectReference(configlist));
 
   std::vector<cmXCodeObject*> targets;
-  for(std::vector<cmLocalGenerator*>::iterator i = generators.begin();
-      i != generators.end(); ++i)
-    {
-    if(!this->IsExcluded(root, *i))
-      {
-      if (!this->CreateXCodeTargets(*i, targets))
-        {
+  for (std::vector<cmLocalGenerator*>::iterator i = generators.begin();
+       i != generators.end(); ++i) {
+    if (!this->IsExcluded(root, *i)) {
+      if (!this->CreateXCodeTargets(*i, targets)) {
         return false;
-        }
       }
     }
+  }
   // loop over all targets and add link and depend info
-  for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
-      i != targets.end(); ++i)
-    {
+  for (std::vector<cmXCodeObject*>::iterator i = targets.begin();
+       i != targets.end(); ++i) {
     cmXCodeObject* t = *i;
     this->AddDependAndLinkInformation(t);
-    }
-  if(this->XcodeVersion < 50)
-    {
+  }
+  if (this->XcodeVersion < 50) {
     // now create xcode depend hack makefile
     this->CreateXCodeDependHackTarget(targets);
-    }
+  }
   // now add all targets to the root object
   cmXCodeObject* allTargets = this->CreateObject(cmXCodeObject::OBJECT_LIST);
-  for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
-      i != targets.end(); ++i)
-    {
+  for (std::vector<cmXCodeObject*>::iterator i = targets.begin();
+       i != targets.end(); ++i) {
     cmXCodeObject* t = *i;
     allTargets->AddObject(t);
     cmXCodeObject* productRef = t->GetObject("productReference");
-    if(productRef)
-      {
+    if (productRef) {
       productGroupChildren->AddObject(productRef->GetObject());
-      }
     }
+  }
   this->RootObject->AddAttribute("targets", allTargets);
   return true;
 }
 
-std::string
-cmGlobalXCodeGenerator::GetObjectsNormalDirectory(
-  const std::string &projName,
-  const std::string &configName,
-  const cmGeneratorTarget *t) const
+std::string cmGlobalXCodeGenerator::GetObjectsNormalDirectory(
+  const std::string& projName, const std::string& configName,
+  const cmGeneratorTarget* t) const
 {
-  std::string dir =
-    t->GetLocalGenerator()->GetCurrentBinaryDirectory();
+  std::string dir = t->GetLocalGenerator()->GetCurrentBinaryDirectory();
   dir += "/";
   dir += projName;
   dir += ".build/";
@@ -3576,18 +3035,15 @@ cmGlobalXCodeGenerator::GetObjectsNormalDirectory(
   return dir;
 }
 
-void
-cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
+void cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
   std::vector<cmXCodeObject*>& targets)
 {
-  cmGeneratedFileStream
-    makefileStream(this->CurrentXCodeHackMakefile.c_str());
-  if(!makefileStream)
-    {
+  cmGeneratedFileStream makefileStream(this->CurrentXCodeHackMakefile.c_str());
+  if (!makefileStream) {
     cmSystemTools::Error("Could not create",
                          this->CurrentXCodeHackMakefile.c_str());
     return;
-    }
+  }
   makefileStream.SetCopyIfDifferent(true);
   // one more pass for external depend information not handled
   // correctly by xcode
@@ -3603,26 +3059,23 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
     "so the target does not have to exist\n";
   /* clang-format on */
   std::set<std::string> emitted;
-  for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
-      i != targets.end(); ++i)
-    {
+  for (std::vector<cmXCodeObject*>::iterator i = targets.begin();
+       i != targets.end(); ++i) {
     cmXCodeObject* target = *i;
     std::map<std::string, cmXCodeObject::StringVec> const& deplibs =
       target->GetDependLibraries();
-    for(std::map<std::string, cmXCodeObject::StringVec>::const_iterator ci
-          = deplibs.begin(); ci != deplibs.end(); ++ci)
-      {
-      for(cmXCodeObject::StringVec::const_iterator d = ci->second.begin();
-          d != ci->second.end(); ++d)
-        {
-        if(emitted.insert(*d).second)
-          {
-          makefileStream <<
-            this->ConvertToRelativeForMake(d->c_str()) << ":\n";
-          }
+    for (std::map<std::string, cmXCodeObject::StringVec>::const_iterator ci =
+           deplibs.begin();
+         ci != deplibs.end(); ++ci) {
+      for (cmXCodeObject::StringVec::const_iterator d = ci->second.begin();
+           d != ci->second.end(); ++d) {
+        if (emitted.insert(*d).second) {
+          makefileStream << this->ConvertToRelativeForMake(d->c_str())
+                         << ":\n";
         }
       }
     }
+  }
   makefileStream << "\n\n";
 
   // Write rules to help Xcode relink things at the right time.
@@ -3632,66 +3085,58 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
     "# link.  This forces Xcode to relink the targets from scratch.  It\n"
     "# does not seem to check these dependencies itself.\n";
   /* clang-format on */
-  for(std::vector<std::string>::const_iterator
-        ct = this->CurrentConfigurationTypes.begin();
-      ct != this->CurrentConfigurationTypes.end(); ++ct)
-    {
+  for (std::vector<std::string>::const_iterator ct =
+         this->CurrentConfigurationTypes.begin();
+       ct != this->CurrentConfigurationTypes.end(); ++ct) {
     std::string configName = *ct;
-    for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
-        i != targets.end(); ++i)
-      {
+    for (std::vector<cmXCodeObject*>::iterator i = targets.begin();
+         i != targets.end(); ++i) {
       cmXCodeObject* target = *i;
-      cmGeneratorTarget* gt =target->GetTarget();
-
-      if(gt->GetType() == cmState::EXECUTABLE ||
-// Nope - no post-build for OBJECT_LIRBRARY
-//         gt->GetType() == cmState::OBJECT_LIBRARY ||
-         gt->GetType() == cmState::STATIC_LIBRARY ||
-         gt->GetType() == cmState::SHARED_LIBRARY ||
-         gt->GetType() == cmState::MODULE_LIBRARY)
-        {
+      cmGeneratorTarget* gt = target->GetTarget();
+
+      if (gt->GetType() == cmState::EXECUTABLE ||
+          // Nope - no post-build for OBJECT_LIRBRARY
+          //         gt->GetType() == cmState::OBJECT_LIBRARY ||
+          gt->GetType() == cmState::STATIC_LIBRARY ||
+          gt->GetType() == cmState::SHARED_LIBRARY ||
+          gt->GetType() == cmState::MODULE_LIBRARY) {
         // Declare an entry point for the target post-build phase.
         makefileStream << this->PostBuildMakeTarget(gt->GetName(), *ct)
                        << ":\n";
-        }
+      }
 
-      if(gt->GetType() == cmState::EXECUTABLE ||
-         gt->GetType() == cmState::SHARED_LIBRARY ||
-         gt->GetType() == cmState::MODULE_LIBRARY)
-        {
+      if (gt->GetType() == cmState::EXECUTABLE ||
+          gt->GetType() == cmState::SHARED_LIBRARY ||
+          gt->GetType() == cmState::MODULE_LIBRARY) {
         std::string tfull = gt->GetFullPath(configName);
         std::string trel = this->ConvertToRelativeForMake(tfull.c_str());
 
         // Add this target to the post-build phases of its dependencies.
-        std::map<std::string, cmXCodeObject::StringVec>::const_iterator
-          y = target->GetDependTargets().find(*ct);
-        if(y != target->GetDependTargets().end())
-          {
+        std::map<std::string, cmXCodeObject::StringVec>::const_iterator y =
+          target->GetDependTargets().find(*ct);
+        if (y != target->GetDependTargets().end()) {
           std::vector<std::string> const& deptgts = y->second;
-          for(std::vector<std::string>::const_iterator d = deptgts.begin();
-              d != deptgts.end(); ++d)
-            {
+          for (std::vector<std::string>::const_iterator d = deptgts.begin();
+               d != deptgts.end(); ++d) {
             makefileStream << this->PostBuildMakeTarget(*d, *ct) << ": "
                            << trel << "\n";
-            }
           }
+        }
 
         // Create a rule for this target.
         makefileStream << trel << ":";
 
         // List dependencies if any exist.
-        std::map<std::string, cmXCodeObject::StringVec>::const_iterator
-          x = target->GetDependLibraries().find(*ct);
-        if(x != target->GetDependLibraries().end())
-          {
+        std::map<std::string, cmXCodeObject::StringVec>::const_iterator x =
+          target->GetDependLibraries().find(*ct);
+        if (x != target->GetDependLibraries().end()) {
           std::vector<std::string> const& deplibs = x->second;
-          for(std::vector<std::string>::const_iterator d = deplibs.begin();
-              d != deplibs.end(); ++d)
-            {
-            makefileStream << "\\\n\t" <<
-              this->ConvertToRelativeForMake(d->c_str());
-            }
+          for (std::vector<std::string>::const_iterator d = deplibs.begin();
+               d != deplibs.end(); ++d) {
+            makefileStream << "\\\n\t"
+                           << this->ConvertToRelativeForMake(d->c_str());
           }
+        }
         // Write the action to remove the target if it is out of date.
         makefileStream << "\n";
         makefileStream << "\t/bin/rm -f "
@@ -3699,69 +3144,59 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
                        << "\n";
         // if building for more than one architecture
         // then remove those exectuables as well
-        if(this->Architectures.size() > 1)
-          {
+        if (this->Architectures.size() > 1) {
           std::string universal = this->GetObjectsNormalDirectory(
             this->CurrentProject, configName, gt);
-          for( std::vector<std::string>::iterator arch =
+          for (std::vector<std::string>::iterator arch =
                  this->Architectures.begin();
-               arch != this->Architectures.end(); ++arch)
-            {
+               arch != this->Architectures.end(); ++arch) {
             std::string universalFile = universal;
             universalFile += *arch;
             universalFile += "/";
             universalFile += gt->GetFullName(configName);
             makefileStream << "\t/bin/rm -f "
-                           <<
-              this->ConvertToRelativeForMake(universalFile.c_str())
+                           << this->ConvertToRelativeForMake(
+                                universalFile.c_str())
                            << "\n";
-            }
           }
-        makefileStream << "\n\n";
         }
+        makefileStream << "\n\n";
       }
     }
+  }
 }
 
-void
-cmGlobalXCodeGenerator::OutputXCodeProject(cmLocalGenerator* root,
-                                           std::vector<cmLocalGenerator*>&
-                                           generators)
+void cmGlobalXCodeGenerator::OutputXCodeProject(
+  cmLocalGenerator* root, std::vector<cmLocalGenerator*>& generators)
 {
-  if(generators.size() == 0)
-    {
+  if (generators.size() == 0) {
     return;
-    }
+  }
   // Skip local generators that are excluded from this project.
-  for(std::vector<cmLocalGenerator*>::iterator g = generators.begin();
-      g != generators.end(); ++g)
-    {
-    if(this->IsExcluded(root, *g))
-      {
+  for (std::vector<cmLocalGenerator*>::iterator g = generators.begin();
+       g != generators.end(); ++g) {
+    if (this->IsExcluded(root, *g)) {
       continue;
-      }
     }
+  }
 
-  if (!this->CreateXCodeObjects(root, generators))
-    {
+  if (!this->CreateXCodeObjects(root, generators)) {
     return;
-    }
+  }
   std::string xcodeDir = root->GetCurrentBinaryDirectory();
   xcodeDir += "/";
   xcodeDir += root->GetProjectName();
   xcodeDir += ".xcode";
-  if(this->XcodeVersion > 20)
-    {
+  if (this->XcodeVersion > 20) {
     xcodeDir += "proj";
-    }
+  }
   cmSystemTools::MakeDirectory(xcodeDir.c_str());
   std::string xcodeProjFile = xcodeDir + "/project.pbxproj";
   cmGeneratedFileStream fout(xcodeProjFile.c_str());
   fout.SetCopyIfDifferent(true);
-  if(!fout)
-    {
+  if (!fout) {
     return;
-    }
+  }
   this->WriteXCodePBXProj(fout, root, generators);
   this->ClearXCodeObjects();
 
@@ -3771,10 +3206,9 @@ cmGlobalXCodeGenerator::OutputXCodeProject(cmLocalGenerator* root,
     root->GetBinaryDirectory());
 }
 
-void
-cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
-                                          cmLocalGenerator* ,
-                                          std::vector<cmLocalGenerator*>& )
+void cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
+                                               cmLocalGenerator*,
+                                               std::vector<cmLocalGenerator*>&)
 {
   SortXCodeObjects();
 
@@ -3787,8 +3221,7 @@ cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
   cmXCodeObject::Indent(1, fout);
   fout << "};\n";
   cmXCodeObject::Indent(1, fout);
-  if(this->XcodeVersion >= 21)
-    {
+  if (this->XcodeVersion >= 21) {
     if (this->XcodeVersion >= 32)
       fout << "objectVersion = 46;\n";
     else if (this->XcodeVersion >= 31)
@@ -3798,12 +3231,10 @@ cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
     else
       fout << "objectVersion = 42;\n";
     cmXCode21Object::PrintList(this->XCodeObjects, fout);
-    }
-  else
-    {
+  } else {
     fout << "objectVersion = 39;\n";
     cmXCodeObject::PrintList(this->XCodeObjects, fout);
-    }
+  }
   cmXCodeObject::Indent(1, fout);
   fout << "rootObject = " << this->RootObject->GetId()
        << " /* Project object */;\n";
@@ -3812,31 +3243,28 @@ cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
 
 const char* cmGlobalXCodeGenerator::GetCMakeCFGIntDir() const
 {
-  return this->XcodeVersion >= 21 ?
-    "$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)" : ".";
+  return this->XcodeVersion >= 21
+    ? "$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)"
+    : ".";
 }
 
-std::string cmGlobalXCodeGenerator::ExpandCFGIntDir(const std::string& str,
-                                        const std::string& config) const
+std::string cmGlobalXCodeGenerator::ExpandCFGIntDir(
+  const std::string& str, const std::string& config) const
 {
   std::string replace1 = "$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)";
   std::string replace2 = "$(CONFIGURATION)";
 
   std::string tmp = str;
-  for(std::string::size_type i = tmp.find(replace1);
-      i != std::string::npos;
-      i = tmp.find(replace1, i))
-    {
+  for (std::string::size_type i = tmp.find(replace1); i != std::string::npos;
+       i = tmp.find(replace1, i)) {
     tmp.replace(i, replace1.size(), config);
     i += config.size();
-    }
-  for(std::string::size_type i = tmp.find(replace2);
-      i != std::string::npos;
-      i = tmp.find(replace2, i))
-    {
+  }
+  for (std::string::size_type i = tmp.find(replace2); i != std::string::npos;
+       i = tmp.find(replace2, i)) {
     tmp.replace(i, replace2.size(), config);
     i += config.size();
-    }
+  }
   return tmp;
 }
 
@@ -3855,66 +3283,55 @@ std::string cmGlobalXCodeGenerator::RelativeToSource(const char* p)
 {
   // We force conversion because Xcode breakpoints do not work unless
   // they are in a file named relative to the source tree.
-  return this->CurrentLocalGenerator->
-    ConvertToRelativePath(this->ProjectSourceDirectoryComponents, p, true);
+  return this->CurrentLocalGenerator->ConvertToRelativePath(
+    this->ProjectSourceDirectoryComponents, p, true);
 }
 
 std::string cmGlobalXCodeGenerator::RelativeToBinary(const char* p)
 {
-  return this->CurrentLocalGenerator->
-    ConvertToRelativePath(this->ProjectOutputDirectoryComponents, p);
+  return this->CurrentLocalGenerator->ConvertToRelativePath(
+    this->ProjectOutputDirectoryComponents, p);
 }
 
 std::string cmGlobalXCodeGenerator::XCodeEscapePath(const std::string& p)
 {
-  if(p.find(' ') != p.npos)
-    {
+  if (p.find(' ') != p.npos) {
     std::string t = "\"";
     t += p;
     t += "\"";
     return t;
-    }
+  }
   return p;
 }
 
-void
-cmGlobalXCodeGenerator
-::AppendDirectoryForConfig(const std::string& prefix,
-                           const std::string& config,
-                           const std::string& suffix,
-                           std::string& dir)
+void cmGlobalXCodeGenerator::AppendDirectoryForConfig(
+  const std::string& prefix, const std::string& config,
+  const std::string& suffix, std::string& dir)
 {
-  if(this->XcodeVersion > 20)
-    {
-    if(!config.empty())
-      {
+  if (this->XcodeVersion > 20) {
+    if (!config.empty()) {
       dir += prefix;
       dir += config;
       dir += suffix;
-      }
     }
+  }
 }
 
 std::string cmGlobalXCodeGenerator::LookupFlags(
-                                              const std::string& varNamePrefix,
-                                              const std::string& varNameLang,
-                                              const std::string& varNameSuffix,
-                                              const std::string& default_flags)
+  const std::string& varNamePrefix, const std::string& varNameLang,
+  const std::string& varNameSuffix, const std::string& default_flags)
 {
-  if(!varNameLang.empty())
-    {
+  if (!varNameLang.empty()) {
     std::string varName = varNamePrefix;
     varName += varNameLang;
     varName += varNameSuffix;
-    if(const char* varValue =
-       this->CurrentMakefile->GetDefinition(varName.c_str()))
-      {
-      if(*varValue)
-        {
+    if (const char* varValue =
+          this->CurrentMakefile->GetDefinition(varName.c_str())) {
+      if (*varValue) {
         return varValue;
-        }
       }
     }
+  }
   return default_flags;
 }
 
@@ -3923,10 +3340,9 @@ void cmGlobalXCodeGenerator::AppendDefines(BuildObjectListOrString& defs,
                                            bool dflag)
 {
   // Skip this if there are no definitions.
-  if(!defines_list)
-    {
+  if (!defines_list) {
     return;
-    }
+  }
 
   // Expand the list of definitions.
   std::vector<std::string> defines;
@@ -3936,41 +3352,37 @@ void cmGlobalXCodeGenerator::AppendDefines(BuildObjectListOrString& defs,
   this->AppendDefines(defs, defines, dflag);
 }
 
-void
-cmGlobalXCodeGenerator::AppendDefines(BuildObjectListOrString& defs,
-                                      std::vector<std::string> const& defines,
-                                      bool dflag)
+void cmGlobalXCodeGenerator::AppendDefines(
+  BuildObjectListOrString& defs, std::vector<std::string> const& defines,
+  bool dflag)
 {
   // GCC_PREPROCESSOR_DEFINITIONS is a space-separated list of definitions.
   std::string def;
-  for(std::vector<std::string>::const_iterator di = defines.begin();
-      di != defines.end(); ++di)
-    {
+  for (std::vector<std::string>::const_iterator di = defines.begin();
+       di != defines.end(); ++di) {
     // Start with -D if requested.
-    def = dflag? "-D": "";
+    def = dflag ? "-D" : "";
     def += *di;
 
     // Append the flag with needed escapes.
     std::string tmp;
     this->AppendFlag(tmp, def);
     defs.Add(tmp);
-    }
+  }
 }
 
 void cmGlobalXCodeGenerator::AppendFlag(std::string& flags,
                                         std::string const& flag)
 {
   // Short-circuit for an empty flag.
-  if(flag.empty())
-    {
+  if (flag.empty()) {
     return;
-    }
+  }
 
   // Separate from previous flags.
-  if(!flags.empty())
-    {
+  if (!flags.empty()) {
     flags += " ";
-    }
+  }
 
   // Check if the flag needs quoting.
   bool quoteFlag =
@@ -3986,48 +3398,36 @@ void cmGlobalXCodeGenerator::AppendFlag(std::string& flags,
   // The final level of escaping is done when the string is stored
   // into the project file by cmXCodeObject::PrintString.
 
-  if(quoteFlag)
-    {
+  if (quoteFlag) {
     // Open single quote.
     flags += "'";
-    }
+  }
 
   // Flag value with escaped quotes and backslashes.
-  for(const char* c = flag.c_str(); *c; ++c)
-    {
-    if(*c == '\'')
-      {
-      if (this->XcodeVersion >= 40)
-        {
+  for (const char* c = flag.c_str(); *c; ++c) {
+    if (*c == '\'') {
+      if (this->XcodeVersion >= 40) {
         flags += "'\\''";
-        }
-      else
-        {
+      } else {
         flags += "\\'";
-        }
       }
-    else if(*c == '\\')
-      {
+    } else if (*c == '\\') {
       flags += "\\\\";
-      }
-    else
-      {
+    } else {
       flags += *c;
-      }
     }
+  }
 
-  if(quoteFlag)
-    {
+  if (quoteFlag) {
     // Close single quote.
     flags += "'";
-    }
+  }
 }
 
-std::string
-cmGlobalXCodeGenerator::ComputeInfoPListLocation(cmGeneratorTarget* target)
+std::string cmGlobalXCodeGenerator::ComputeInfoPListLocation(
+  cmGeneratorTarget* target)
 {
-  std::string plist =
-      target->GetLocalGenerator()->GetCurrentBinaryDirectory();
+  std::string plist = target->GetLocalGenerator()->GetCurrentBinaryDirectory();
   plist += cmake::GetCMakeFilesDirectory();
   plist += "/";
   plist += target->GetName();
@@ -4040,33 +3440,29 @@ cmGlobalXCodeGenerator::ComputeInfoPListLocation(cmGeneratorTarget* target)
 bool cmGlobalXCodeGenerator::IsMultiConfig()
 {
   // Old Xcode 1.5 is single config:
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     return false;
-    }
+  }
 
   // Newer Xcode versions are multi config:
   return true;
 }
 
-void cmGlobalXCodeGenerator
-::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const
+void cmGlobalXCodeGenerator::ComputeTargetObjectDirectory(
+  cmGeneratorTarget* gt) const
 {
   std::string configName = this->GetCMakeCFGIntDir();
-  std::string dir = this->GetObjectsNormalDirectory(
-    "$(PROJECT_NAME)", configName, gt);
-  if(this->XcodeVersion >= 21)
-    {
+  std::string dir =
+    this->GetObjectsNormalDirectory("$(PROJECT_NAME)", configName, gt);
+  if (this->XcodeVersion >= 21) {
     dir += "$(CURRENT_ARCH)/";
-    }
-  else
-    {
+  } else {
 #ifdef __ppc__
     dir += "ppc/";
 #endif
 #ifdef __i386
     dir += "i386/";
 #endif
-    }
+  }
   gt->ObjectDirectory = dir;
 }