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, 153 insertions, 219 deletions

diff --git a/Source/cmGlobalVisualStudio10Generator.cxx b/Source/cmGlobalVisualStudio10Generator.cxx
index 441c2df..90ff98b 100644
--- a/Source/cmGlobalVisualStudio10Generator.cxx
+++ b/Source/cmGlobalVisualStudio10Generator.cxx
@@ -26,16 +26,14 @@ static const char vs10generatorName[] = "Visual Studio 10 2010";
 // Map generator name without year to name with year.
 static const char* cmVS10GenName(const std::string& name, std::string& genName)
 {
-  if(strncmp(name.c_str(), vs10generatorName,
-             sizeof(vs10generatorName)-6) != 0)
-    {
+  if (strncmp(name.c_str(), vs10generatorName,
+              sizeof(vs10generatorName) - 6) != 0) {
     return 0;
-    }
+  }
   const char* p = name.c_str() + sizeof(vs10generatorName) - 6;
-  if(cmHasLiteralPrefix(p, " 2010"))
-    {
+  if (cmHasLiteralPrefix(p, " 2010")) {
     p += 5;
-    }
+  }
   genName = std::string(vs10generatorName) + p;
   return p;
 }
@@ -44,45 +42,42 @@ class cmGlobalVisualStudio10Generator::Factory
   : public cmGlobalGeneratorFactory
 {
 public:
-  virtual cmGlobalGenerator*
-  CreateGlobalGenerator(const std::string& name, cmake* cm) const
-    {
+  virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
+                                                   cmake* cm) const
+  {
     std::string genName;
     const char* p = cmVS10GenName(name, genName);
-    if(!p)
-      { return 0; }
-    if(!*p)
-      {
+    if (!p) {
+      return 0;
+    }
+    if (!*p) {
       return new cmGlobalVisualStudio10Generator(cm, genName, "");
-      }
-    if(*p++ != ' ')
-      { return 0; }
-    if(strcmp(p, "Win64") == 0)
-      {
+    }
+    if (*p++ != ' ') {
+      return 0;
+    }
+    if (strcmp(p, "Win64") == 0) {
       return new cmGlobalVisualStudio10Generator(cm, genName, "x64");
-      }
-    if(strcmp(p, "IA64") == 0)
-      {
+    }
+    if (strcmp(p, "IA64") == 0) {
       return new cmGlobalVisualStudio10Generator(cm, genName, "Itanium");
-      }
-    return 0;
     }
+    return 0;
+  }
 
   virtual void GetDocumentation(cmDocumentationEntry& entry) const
-    {
+  {
     entry.Name = std::string(vs10generatorName) + " [arch]";
-    entry.Brief =
-      "Generates Visual Studio 2010 project files.  "
-      "Optional [arch] can be \"Win64\" or \"IA64\"."
-      ;
-    }
+    entry.Brief = "Generates Visual Studio 2010 project files.  "
+                  "Optional [arch] can be \"Win64\" or \"IA64\".";
+  }
 
   virtual void GetGenerators(std::vector<std::string>& names) const
-    {
+  {
     names.push_back(vs10generatorName);
     names.push_back(vs10generatorName + std::string(" IA64"));
     names.push_back(vs10generatorName + std::string(" Win64"));
-    }
+  }
 
   virtual bool SupportsToolset() const { return true; }
 };
@@ -92,14 +87,15 @@ cmGlobalGeneratorFactory* cmGlobalVisualStudio10Generator::NewFactory()
   return new Factory;
 }
 
-cmGlobalVisualStudio10Generator::cmGlobalVisualStudio10Generator(cmake* cm,
-  const std::string& name, const std::string& platformName)
+cmGlobalVisualStudio10Generator::cmGlobalVisualStudio10Generator(
+  cmake* cm, const std::string& name, const std::string& platformName)
   : cmGlobalVisualStudio8Generator(cm, name, platformName)
 {
   std::string vc10Express;
   this->ExpressEdition = cmSystemTools::ReadRegistryValue(
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\10.0\\Setup\\VC;"
-    "ProductDir", vc10Express, cmSystemTools::KeyWOW64_32);
+    "ProductDir",
+    vc10Express, cmSystemTools::KeyWOW64_32);
   this->SystemIsWindowsCE = false;
   this->SystemIsWindowsPhone = false;
   this->SystemIsWindowsStore = false;
@@ -107,15 +103,13 @@ cmGlobalVisualStudio10Generator::cmGlobalVisualStudio10Generator(cmake* cm,
   this->Version = VS10;
 }
 
-bool
-cmGlobalVisualStudio10Generator::MatchesGeneratorName(
-                                               const std::string& name) const
+bool cmGlobalVisualStudio10Generator::MatchesGeneratorName(
+  const std::string& name) const
 {
   std::string genName;
-  if(cmVS10GenName(name, genName))
-    {
+  if (cmVS10GenName(name, genName)) {
     return genName == this->GetName();
-    }
+  }
   return false;
 }
 
@@ -124,110 +118,88 @@ bool cmGlobalVisualStudio10Generator::SetSystemName(std::string const& s,
 {
   this->SystemName = s;
   this->SystemVersion = mf->GetSafeDefinition("CMAKE_SYSTEM_VERSION");
-  if(!this->InitializeSystem(mf))
-    {
+  if (!this->InitializeSystem(mf)) {
     return false;
-    }
+  }
   return this->cmGlobalVisualStudio8Generator::SetSystemName(s, mf);
 }
 
-bool
-cmGlobalVisualStudio10Generator::SetGeneratorPlatform(std::string const& p,
-                                                      cmMakefile* mf)
+bool cmGlobalVisualStudio10Generator::SetGeneratorPlatform(
+  std::string const& p, cmMakefile* mf)
 {
-  if(!this->cmGlobalVisualStudio8Generator::SetGeneratorPlatform(p, mf))
-    {
+  if (!this->cmGlobalVisualStudio8Generator::SetGeneratorPlatform(p, mf)) {
     return false;
-    }
-  if(this->GetPlatformName() == "Itanium" || this->GetPlatformName() == "x64")
-    {
-    if(this->IsExpressEdition() && !this->Find64BitTools(mf))
-      {
+  }
+  if (this->GetPlatformName() == "Itanium" ||
+      this->GetPlatformName() == "x64") {
+    if (this->IsExpressEdition() && !this->Find64BitTools(mf)) {
       return false;
-      }
     }
+  }
   return true;
 }
 
-bool
-cmGlobalVisualStudio10Generator::SetGeneratorToolset(std::string const& ts,
-                                                     cmMakefile* mf)
+bool cmGlobalVisualStudio10Generator::SetGeneratorToolset(
+  std::string const& ts, cmMakefile* mf)
 {
   if (this->SystemIsWindowsCE && ts.empty() &&
-      this->DefaultPlatformToolset.empty())
-    {
+      this->DefaultPlatformToolset.empty()) {
     std::ostringstream e;
     e << this->GetName() << " Windows CE version '" << this->SystemVersion
       << "' requires CMAKE_GENERATOR_TOOLSET to be set.";
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
 
   this->GeneratorToolset = ts;
-  if(const char* toolset = this->GetPlatformToolset())
-    {
+  if (const char* toolset = this->GetPlatformToolset()) {
     mf->AddDefinition("CMAKE_VS_PLATFORM_TOOLSET", toolset);
-    }
+  }
   return true;
 }
 
 bool cmGlobalVisualStudio10Generator::InitializeSystem(cmMakefile* mf)
 {
-  if (this->SystemName == "Windows")
-    {
-    if (!this->InitializeWindows(mf))
-      {
+  if (this->SystemName == "Windows") {
+    if (!this->InitializeWindows(mf)) {
       return false;
-      }
     }
-  else if (this->SystemName == "WindowsCE")
-    {
+  } else if (this->SystemName == "WindowsCE") {
     this->SystemIsWindowsCE = true;
-    if (!this->InitializeWindowsCE(mf))
-      {
+    if (!this->InitializeWindowsCE(mf)) {
       return false;
-      }
     }
-  else if (this->SystemName == "WindowsPhone")
-    {
+  } else if (this->SystemName == "WindowsPhone") {
     this->SystemIsWindowsPhone = true;
-    if(!this->InitializeWindowsPhone(mf))
-      {
+    if (!this->InitializeWindowsPhone(mf)) {
       return false;
-      }
     }
-  else if (this->SystemName == "WindowsStore")
-    {
+  } else if (this->SystemName == "WindowsStore") {
     this->SystemIsWindowsStore = true;
-    if(!this->InitializeWindowsStore(mf))
-      {
+    if (!this->InitializeWindowsStore(mf)) {
       return false;
-      }
     }
-  else if(this->SystemName == "Android")
-    {
-    if(this->DefaultPlatformName != "Win32")
-      {
+  } else if (this->SystemName == "Android") {
+    if (this->DefaultPlatformName != "Win32") {
       std::ostringstream e;
       e << "CMAKE_SYSTEM_NAME is 'Android' but CMAKE_GENERATOR "
         << "specifies a platform too: '" << this->GetName() << "'";
       mf->IssueMessage(cmake::FATAL_ERROR, e.str());
       return false;
-      }
+    }
     std::string v = this->GetInstalledNsightTegraVersion();
-    if(v.empty())
-      {
+    if (v.empty()) {
       mf->IssueMessage(cmake::FATAL_ERROR,
-        "CMAKE_SYSTEM_NAME is 'Android' but "
-        "'NVIDIA Nsight Tegra Visual Studio Edition' "
-        "is not installed.");
+                       "CMAKE_SYSTEM_NAME is 'Android' but "
+                       "'NVIDIA Nsight Tegra Visual Studio Edition' "
+                       "is not installed.");
       return false;
-      }
+    }
     this->DefaultPlatformName = "Tegra-Android";
     this->DefaultPlatformToolset = "Default";
     this->NsightTegraVersion = v;
     mf->AddDefinition("CMAKE_VS_NsightTegra_VERSION", v.c_str());
-    }
+  }
 
   return true;
 }
@@ -239,14 +211,13 @@ bool cmGlobalVisualStudio10Generator::InitializeWindows(cmMakefile*)
 
 bool cmGlobalVisualStudio10Generator::InitializeWindowsCE(cmMakefile* mf)
 {
-  if (this->DefaultPlatformName != "Win32")
-    {
+  if (this->DefaultPlatformName != "Win32") {
     std::ostringstream e;
     e << "CMAKE_SYSTEM_NAME is 'WindowsCE' but CMAKE_GENERATOR "
       << "specifies a platform too: '" << this->GetName() << "'";
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
 
   this->DefaultPlatformToolset = this->SelectWindowsCEToolset();
 
@@ -269,16 +240,14 @@ bool cmGlobalVisualStudio10Generator::InitializeWindowsStore(cmMakefile* mf)
   return false;
 }
 
-bool
-cmGlobalVisualStudio10Generator::SelectWindowsPhoneToolset(
+bool cmGlobalVisualStudio10Generator::SelectWindowsPhoneToolset(
   std::string& toolset) const
 {
   toolset = "";
   return false;
 }
 
-bool
-cmGlobalVisualStudio10Generator::SelectWindowsStoreToolset(
+bool cmGlobalVisualStudio10Generator::SelectWindowsStoreToolset(
   std::string& toolset) const
 {
   toolset = "";
@@ -287,29 +256,25 @@ cmGlobalVisualStudio10Generator::SelectWindowsStoreToolset(
 
 std::string cmGlobalVisualStudio10Generator::SelectWindowsCEToolset() const
 {
-  if (this->SystemVersion == "8.0")
-    {
+  if (this->SystemVersion == "8.0") {
     return "CE800";
-    }
+  }
   return "";
 }
 
 void cmGlobalVisualStudio10Generator::WriteSLNHeader(std::ostream& fout)
 {
   fout << "Microsoft Visual Studio Solution File, Format Version 11.00\n";
-  if (this->ExpressEdition)
-    {
+  if (this->ExpressEdition) {
     fout << "# Visual C++ Express 2010\n";
-    }
-  else
-    {
+  } else {
     fout << "# Visual Studio 2010\n";
-    }
+  }
 }
 
 ///! Create a local generator appropriate to this Global Generator
 cmLocalGenerator* cmGlobalVisualStudio10Generator::CreateLocalGenerator(
-    cmMakefile* mf)
+  cmMakefile* mf)
 {
   return new cmLocalVisualStudio10Generator(this, mf);
 }
@@ -318,8 +283,7 @@ void cmGlobalVisualStudio10Generator::Generate()
 {
   this->LongestSource = LongestSourcePath();
   this->cmGlobalVisualStudio8Generator::Generate();
-  if(this->LongestSource.Length > 0)
-    {
+  if (this->LongestSource.Length > 0) {
     cmLocalGenerator* lg = this->LongestSource.Target->GetLocalGenerator();
     std::ostringstream e;
     /* clang-format off */
@@ -344,26 +308,23 @@ void cmGlobalVisualStudio10Generator::Generate()
       "which then triggers the VS 10 property dialog bug.";
     /* clang-format on */
     lg->IssueMessage(cmake::WARNING, e.str().c_str());
-    }
+  }
 }
 
-void cmGlobalVisualStudio10Generator
-::EnableLanguage(std::vector<std::string>const &  lang,
-                 cmMakefile *mf, bool optional)
+void cmGlobalVisualStudio10Generator::EnableLanguage(
+  std::vector<std::string> const& lang, cmMakefile* mf, bool optional)
 {
   cmGlobalVisualStudio8Generator::EnableLanguage(lang, mf, optional);
 }
 
 const char* cmGlobalVisualStudio10Generator::GetPlatformToolset() const
 {
-  if(!this->GeneratorToolset.empty())
-    {
+  if (!this->GeneratorToolset.empty()) {
     return this->GeneratorToolset.c_str();
-    }
-  if(!this->DefaultPlatformToolset.empty())
-    {
+  }
+  if (!this->DefaultPlatformToolset.empty()) {
     return this->DefaultPlatformToolset.c_str();
-    }
+  }
   return 0;
 }
 
@@ -376,11 +337,10 @@ void cmGlobalVisualStudio10Generator::FindMakeProgram(cmMakefile* mf)
 
 std::string const& cmGlobalVisualStudio10Generator::GetMSBuildCommand()
 {
-  if(!this->MSBuildCommandInitialized)
-    {
+  if (!this->MSBuildCommandInitialized) {
     this->MSBuildCommandInitialized = true;
     this->MSBuildCommand = this->FindMSBuildCommand();
-    }
+  }
   return this->MSBuildCommand;
 }
 
@@ -391,39 +351,33 @@ std::string cmGlobalVisualStudio10Generator::FindMSBuildCommand()
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\MSBuild\\ToolsVersions\\";
   mskey += this->GetToolsVersion();
   mskey += ";MSBuildToolsPath";
-  if(cmSystemTools::ReadRegistryValue(mskey.c_str(), msbuild,
-                                      cmSystemTools::KeyWOW64_32))
-    {
+  if (cmSystemTools::ReadRegistryValue(mskey.c_str(), msbuild,
+                                       cmSystemTools::KeyWOW64_32)) {
     cmSystemTools::ConvertToUnixSlashes(msbuild);
     msbuild += "/";
-    }
+  }
   msbuild += "MSBuild.exe";
   return msbuild;
 }
 
 std::string cmGlobalVisualStudio10Generator::FindDevEnvCommand()
 {
-  if(this->ExpressEdition)
-    {
+  if (this->ExpressEdition) {
     // Visual Studio Express >= 10 do not have "devenv.com" or
     // "VCExpress.exe" that we can use to build reliably.
     // Tell the caller it needs to use MSBuild instead.
     return "";
-    }
+  }
   // Skip over the cmGlobalVisualStudio8Generator implementation because
   // we expect a real devenv and do not want to look for VCExpress.
   return this->cmGlobalVisualStudio71Generator::FindDevEnvCommand();
 }
 
 void cmGlobalVisualStudio10Generator::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)
+  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)
 {
   // Select the caller- or user-preferred make program, else MSBuild.
   std::string makeProgramSelected =
@@ -432,99 +386,82 @@ void cmGlobalVisualStudio10Generator::GenerateBuildCommand(
   // Check if the caller explicitly requested a devenv tool.
   std::string makeProgramLower = makeProgramSelected;
   cmSystemTools::LowerCase(makeProgramLower);
-  bool useDevEnv =
-    (makeProgramLower.find("devenv") != std::string::npos ||
-     makeProgramLower.find("vcexpress") != std::string::npos);
+  bool useDevEnv = (makeProgramLower.find("devenv") != std::string::npos ||
+                    makeProgramLower.find("vcexpress") != std::string::npos);
 
   // MSBuild is preferred (and required for VS Express), but if the .sln has
   // an Intel Fortran .vfproj then we have to use devenv. Parse it to find out.
   cmSlnData slnData;
   {
-  std::string slnFile;
-  if(!projectDir.empty())
-    {
-    slnFile = projectDir;
-    slnFile += "/";
-    }
-  slnFile += projectName;
-  slnFile += ".sln";
-  cmVisualStudioSlnParser parser;
-  if(parser.ParseFile(slnFile, slnData,
-                      cmVisualStudioSlnParser::DataGroupProjects))
-    {
-    std::vector<cmSlnProjectEntry> slnProjects = slnData.GetProjects();
-    for(std::vector<cmSlnProjectEntry>::iterator i = slnProjects.begin();
-        !useDevEnv && i != slnProjects.end(); ++i)
-      {
-      std::string proj = i->GetRelativePath();
-      if(proj.size() > 7 &&
-         proj.substr(proj.size()-7) == ".vfproj")
-        {
-        useDevEnv = true;
+    std::string slnFile;
+    if (!projectDir.empty()) {
+      slnFile = projectDir;
+      slnFile += "/";
+    }
+    slnFile += projectName;
+    slnFile += ".sln";
+    cmVisualStudioSlnParser parser;
+    if (parser.ParseFile(slnFile, slnData,
+                         cmVisualStudioSlnParser::DataGroupProjects)) {
+      std::vector<cmSlnProjectEntry> slnProjects = slnData.GetProjects();
+      for (std::vector<cmSlnProjectEntry>::iterator i = slnProjects.begin();
+           !useDevEnv && i != slnProjects.end(); ++i) {
+        std::string proj = i->GetRelativePath();
+        if (proj.size() > 7 && proj.substr(proj.size() - 7) == ".vfproj") {
+          useDevEnv = true;
         }
       }
     }
   }
-  if(useDevEnv)
-    {
+  if (useDevEnv) {
     // Use devenv to build solutions containing Intel Fortran projects.
     cmGlobalVisualStudio7Generator::GenerateBuildCommand(
-      makeCommand, makeProgram, projectName, projectDir,
-      targetName, config, fast, verbose, makeOptions);
+      makeCommand, makeProgram, projectName, projectDir, targetName, config,
+      fast, verbose, makeOptions);
     return;
-    }
+  }
 
   makeCommand.push_back(makeProgramSelected);
 
   std::string realTarget = targetName;
   // msbuild.exe CxxOnly.sln /t:Build /p:Configuration=Debug /target:ALL_BUILD
-  if(realTarget.empty())
-    {
+  if (realTarget.empty()) {
     realTarget = "ALL_BUILD";
-    }
-  if ( realTarget == "clean" )
-    {
-    makeCommand.push_back(std::string(projectName)+".sln");
+  }
+  if (realTarget == "clean") {
+    makeCommand.push_back(std::string(projectName) + ".sln");
     makeCommand.push_back("/t:Clean");
-    }
-  else
-    {
+  } else {
     std::string targetProject(realTarget);
     targetProject += ".vcxproj";
-    if (targetProject.find('/') == std::string::npos)
-      {
+    if (targetProject.find('/') == std::string::npos) {
       // it might be in a subdir
       if (cmSlnProjectEntry const* proj =
-          slnData.GetProjectByName(realTarget))
-        {
+            slnData.GetProjectByName(realTarget)) {
         targetProject = proj->GetRelativePath();
         cmSystemTools::ConvertToUnixSlashes(targetProject);
-        }
       }
-    makeCommand.push_back(targetProject);
     }
+    makeCommand.push_back(targetProject);
+  }
   std::string configArg = "/p:Configuration=";
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     configArg += config;
-    }
-  else
-    {
+  } else {
     configArg += "Debug";
-    }
+  }
   makeCommand.push_back(configArg);
-  makeCommand.push_back(std::string("/p:VisualStudioVersion=")+
+  makeCommand.push_back(std::string("/p:VisualStudioVersion=") +
                         this->GetIDEVersion());
-  makeCommand.insert(makeCommand.end(),
-                     makeOptions.begin(), makeOptions.end());
+  makeCommand.insert(makeCommand.end(), makeOptions.begin(),
+                     makeOptions.end());
 }
 
 bool cmGlobalVisualStudio10Generator::Find64BitTools(cmMakefile* mf)
 {
-  if(this->GetPlatformToolset())
-    {
+  if (this->GetPlatformToolset()) {
     return true;
-    }
+  }
   // This edition does not come with 64-bit tools.  Look for them.
   //
   // TODO: Detect available tools?  x64\v100 exists but does not work?
@@ -532,18 +469,16 @@ bool cmGlobalVisualStudio10Generator::Find64BitTools(cmMakefile* mf)
   // c:/Program Files (x86)/MSBuild/Microsoft.Cpp/v4.0/Platforms/
   //   {Itanium,Win32,x64}/PlatformToolsets/{v100,v90,Windows7.1SDK}
   std::string winSDK_7_1;
-  if(cmSystemTools::ReadRegistryValue(
-       "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\"
-       "Windows\\v7.1;InstallationFolder", winSDK_7_1))
-    {
+  if (cmSystemTools::ReadRegistryValue(
+        "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\"
+        "Windows\\v7.1;InstallationFolder",
+        winSDK_7_1)) {
     std::ostringstream m;
     m << "Found Windows SDK v7.1: " << winSDK_7_1;
     mf->DisplayStatus(m.str().c_str(), -1);
     this->DefaultPlatformToolset = "Windows7.1SDK";
     return true;
-    }
-  else
-    {
+  } else {
     std::ostringstream e;
     /* clang-format off */
     e << "Cannot enable 64-bit tools with Visual Studio 2010 Express.\n"
@@ -553,12 +488,11 @@ bool cmGlobalVisualStudio10Generator::Find64BitTools(cmMakefile* mf)
     mf->IssueMessage(cmake::FATAL_ERROR, e.str().c_str());
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
+  }
 }
 
-std::string
-cmGlobalVisualStudio10Generator
-::GenerateRuleFile(std::string const& output) const
+std::string cmGlobalVisualStudio10Generator::GenerateRuleFile(
+  std::string const& output) const
 {
   // The VS 10 generator needs to create the .rule files on disk.
   // Hide them away under the CMakeFiles directory.
@@ -573,20 +507,19 @@ cmGlobalVisualStudio10Generator
   return ruleFile;
 }
 
-void cmGlobalVisualStudio10Generator::PathTooLong(
-        cmGeneratorTarget *target, cmSourceFile const* sf,
-        std::string const& sfRel)
+void cmGlobalVisualStudio10Generator::PathTooLong(cmGeneratorTarget* target,
+                                                  cmSourceFile const* sf,
+                                                  std::string const& sfRel)
 {
   size_t len =
-      (strlen(target->GetLocalGenerator()->GetCurrentBinaryDirectory()) +
-                1 + sfRel.length());
-  if(len > this->LongestSource.Length)
-    {
+    (strlen(target->GetLocalGenerator()->GetCurrentBinaryDirectory()) + 1 +
+     sfRel.length());
+  if (len > this->LongestSource.Length) {
     this->LongestSource.Length = len;
     this->LongestSource.Target = target;
     this->LongestSource.SourceFile = sf;
     this->LongestSource.SourceRel = sfRel;
-    }
+  }
 }
 
 bool cmGlobalVisualStudio10Generator::IsNsightTegra() const
@@ -604,6 +537,7 @@ std::string cmGlobalVisualStudio10Generator::GetInstalledNsightTegraVersion()
   std::string version;
   cmSystemTools::ReadRegistryValue(
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\NVIDIA Corporation\\Nsight Tegra;"
-    "Version", version, cmSystemTools::KeyWOW64_32);
+    "Version",
+    version, cmSystemTools::KeyWOW64_32);
   return version;
 }