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, 193 insertions, 236 deletions

diff --git a/Source/cmGlobalVisualStudio8Generator.cxx b/Source/cmGlobalVisualStudio8Generator.cxx
index 76baf0d..dfe196a 100644
--- a/Source/cmGlobalVisualStudio8Generator.cxx
+++ b/Source/cmGlobalVisualStudio8Generator.cxx
@@ -22,69 +22,64 @@
 
 static const char vs8generatorName[] = "Visual Studio 8 2005";
 
-class cmGlobalVisualStudio8Generator::Factory
-  : public cmGlobalGeneratorFactory
+class cmGlobalVisualStudio8Generator::Factory : public cmGlobalGeneratorFactory
 {
 public:
-  virtual cmGlobalGenerator*
-  CreateGlobalGenerator(const std::string& name, cmake* cm) const {
-    if(strncmp(name.c_str(), vs8generatorName,
-               sizeof(vs8generatorName) - 1) != 0)
-      {
+  virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
+                                                   cmake* cm) const
+  {
+    if (strncmp(name.c_str(), vs8generatorName,
+                sizeof(vs8generatorName) - 1) != 0) {
       return 0;
-      }
+    }
 
     const char* p = name.c_str() + sizeof(vs8generatorName) - 1;
-    if(p[0] == '\0')
-      {
+    if (p[0] == '\0') {
       return new cmGlobalVisualStudio8Generator(cm, name, "");
-      }
+    }
 
-    if(p[0] != ' ')
-      {
+    if (p[0] != ' ') {
       return 0;
-      }
+    }
 
     ++p;
 
-    if(!strcmp(p, "Win64"))
-      {
+    if (!strcmp(p, "Win64")) {
       return new cmGlobalVisualStudio8Generator(cm, name, "x64");
-      }
+    }
 
     cmVisualStudioWCEPlatformParser parser(p);
     parser.ParseVersion("8.0");
-    if (!parser.Found())
-      {
+    if (!parser.Found()) {
       return 0;
-      }
+    }
 
     cmGlobalVisualStudio8Generator* ret =
-        new cmGlobalVisualStudio8Generator(cm, name, p);
+      new cmGlobalVisualStudio8Generator(cm, name, p);
     ret->WindowsCEVersion = parser.GetOSVersion();
     return ret;
   }
 
-  virtual void GetDocumentation(cmDocumentationEntry& entry) const {
+  virtual void GetDocumentation(cmDocumentationEntry& entry) const
+  {
     entry.Name = std::string(vs8generatorName) + " [arch]";
-    entry.Brief =
-      "Generates Visual Studio 2005 project files.  "
-      "Optional [arch] can be \"Win64\"."
-      ;
+    entry.Brief = "Generates Visual Studio 2005 project files.  "
+                  "Optional [arch] can be \"Win64\".";
   }
 
-  virtual void GetGenerators(std::vector<std::string>& names) const {
+  virtual void GetGenerators(std::vector<std::string>& names) const
+  {
     names.push_back(vs8generatorName);
     names.push_back(vs8generatorName + std::string(" Win64"));
     cmVisualStudioWCEPlatformParser parser;
     parser.ParseVersion("8.0");
     const std::vector<std::string>& availablePlatforms =
       parser.GetAvailablePlatforms();
-    for(std::vector<std::string>::const_iterator i =
-        availablePlatforms.begin(); i != availablePlatforms.end(); ++i)
-      {
+    for (std::vector<std::string>::const_iterator i =
+           availablePlatforms.begin();
+         i != availablePlatforms.end(); ++i) {
       names.push_back("Visual Studio 8 2005 " + *i);
-      }
+    }
   }
 
   virtual bool SupportsToolset() const { return false; }
@@ -95,8 +90,8 @@ cmGlobalGeneratorFactory* cmGlobalVisualStudio8Generator::NewFactory()
   return new Factory;
 }
 
-cmGlobalVisualStudio8Generator::cmGlobalVisualStudio8Generator(cmake* cm,
-  const std::string& name, const std::string& platformName)
+cmGlobalVisualStudio8Generator::cmGlobalVisualStudio8Generator(
+  cmake* cm, const std::string& name, const std::string& platformName)
   : cmGlobalVisualStudio71Generator(cm, platformName)
 {
   this->ProjectConfigurationSectionName = "ProjectConfigurationPlatforms";
@@ -106,65 +101,57 @@ cmGlobalVisualStudio8Generator::cmGlobalVisualStudio8Generator(cmake* cm,
   std::string vc8Express;
   this->ExpressEdition = cmSystemTools::ReadRegistryValue(
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\8.0\\Setup\\VC;"
-    "ProductDir", vc8Express, cmSystemTools::KeyWOW64_32);
+    "ProductDir",
+    vc8Express, cmSystemTools::KeyWOW64_32);
 }
 
 std::string cmGlobalVisualStudio8Generator::FindDevEnvCommand()
 {
   // First look for VCExpress.
   std::string vsxcmd;
-  std::string vsxkey =
-    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\";
+  std::string vsxkey = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\";
   vsxkey += this->GetIDEVersion();
   vsxkey += ";InstallDir";
-  if(cmSystemTools::ReadRegistryValue(vsxkey.c_str(), vsxcmd,
-                                      cmSystemTools::KeyWOW64_32))
-    {
+  if (cmSystemTools::ReadRegistryValue(vsxkey.c_str(), vsxcmd,
+                                       cmSystemTools::KeyWOW64_32)) {
     cmSystemTools::ConvertToUnixSlashes(vsxcmd);
     vsxcmd += "/VCExpress.exe";
     return vsxcmd;
-    }
+  }
   // Now look for devenv.
   return this->cmGlobalVisualStudio71Generator::FindDevEnvCommand();
 }
 
-void cmGlobalVisualStudio8Generator
-::EnableLanguage(std::vector<std::string>const &  lang,
-                 cmMakefile *mf, bool optional)
+void cmGlobalVisualStudio8Generator::EnableLanguage(
+  std::vector<std::string> const& lang, cmMakefile* mf, bool optional)
 {
-  for(std::vector<std::string>::const_iterator it = lang.begin();
-      it != lang.end(); ++it)
-    {
-    if(*it == "ASM_MASM")
-      {
+  for (std::vector<std::string>::const_iterator it = lang.begin();
+       it != lang.end(); ++it) {
+    if (*it == "ASM_MASM") {
       this->MasmEnabled = true;
-      }
     }
+  }
   this->AddPlatformDefinitions(mf);
   cmGlobalVisualStudio7Generator::EnableLanguage(lang, mf, optional);
 }
 
 void cmGlobalVisualStudio8Generator::AddPlatformDefinitions(cmMakefile* mf)
 {
-  if(this->TargetsWindowsCE())
-  {
+  if (this->TargetsWindowsCE()) {
     mf->AddDefinition("CMAKE_VS_WINCE_VERSION",
-      this->WindowsCEVersion.c_str());
+                      this->WindowsCEVersion.c_str());
   }
 }
 
 bool cmGlobalVisualStudio8Generator::SetGeneratorPlatform(std::string const& p,
                                                           cmMakefile* mf)
 {
-  if(this->DefaultPlatformName == "Win32")
-    {
+  if (this->DefaultPlatformName == "Win32") {
     this->GeneratorPlatform = p;
     return this->cmGlobalVisualStudio7Generator::SetGeneratorPlatform("", mf);
-    }
-  else
-    {
+  } else {
     return this->cmGlobalVisualStudio7Generator::SetGeneratorPlatform(p, mf);
-    }
+  }
 }
 
 // ouput standard header for dsw file
@@ -174,8 +161,8 @@ void cmGlobalVisualStudio8Generator::WriteSLNHeader(std::ostream& fout)
   fout << "# Visual Studio 2005\n";
 }
 
-void cmGlobalVisualStudio8Generator
-::GetDocumentation(cmDocumentationEntry& entry)
+void cmGlobalVisualStudio8Generator::GetDocumentation(
+  cmDocumentationEntry& entry)
 {
   entry.Name = cmGlobalVisualStudio8Generator::GetActualName();
   entry.Brief = "Generates Visual Studio 8 2005 project files.";
@@ -203,25 +190,23 @@ std::string cmGlobalVisualStudio8Generator::GetUserMacrosDirectory()
     "InstalledProducts\\KB926748;";
   std::string vc8sp1;
   if (!cmSystemTools::ReadRegistryValue(vc8sp1Registry, vc8sp1) &&
-      !cmSystemTools::ReadRegistryValue(vc8exSP1Registry, vc8sp1))
-    {
+      !cmSystemTools::ReadRegistryValue(vc8exSP1Registry, vc8sp1)) {
     return "";
-    }
+  }
 
   std::string base;
   std::string path;
 
   // base begins with the VisualStudioProjectsLocation reg value...
   if (cmSystemTools::ReadRegistryValue(
-    "HKEY_CURRENT_USER\\Software\\Microsoft\\VisualStudio\\8.0;"
-    "VisualStudioProjectsLocation",
-    base))
-    {
+        "HKEY_CURRENT_USER\\Software\\Microsoft\\VisualStudio\\8.0;"
+        "VisualStudioProjectsLocation",
+        base)) {
     cmSystemTools::ConvertToUnixSlashes(base);
 
     // 8.0 macros folder:
     path = base + "/VSMacros80";
-    }
+  }
 
   // path is (correctly) still empty if we did not read the base value from
   // the Registry value
@@ -245,103 +230,93 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget()
   cmMakefile* mf = lg->GetMakefile();
 
   // Skip the target if no regeneration is to be done.
-  if(mf->IsOn("CMAKE_SUPPRESS_REGENERATION"))
-    {
+  if (mf->IsOn("CMAKE_SUPPRESS_REGENERATION")) {
     return false;
-    }
+  }
 
   cmCustomCommandLines noCommandLines;
   cmTarget* tgt =
     mf->AddUtilityCommand(CMAKE_CHECK_BUILD_SYSTEM_TARGET, false,
-                          no_working_directory, no_depends,
-                          noCommandLines);
+                          no_working_directory, no_depends, noCommandLines);
 
   cmGeneratorTarget* gt = new cmGeneratorTarget(tgt, lg);
   lg->AddGeneratorTarget(gt);
 
   // Organize in the "predefined targets" folder:
   //
-  if (this->UseFolderProperty())
-    {
+  if (this->UseFolderProperty()) {
     tgt->SetProperty("FOLDER", this->GetPredefinedTargetsFolder());
-    }
+  }
 
   // Create a list of all stamp files for this project.
   std::vector<std::string> stamps;
   std::string stampList = cmake::GetCMakeFilesDirectoryPostSlash();
   stampList += "generate.stamp.list";
   {
-  std::string stampListFile =
-    generators[0]->GetMakefile()->GetCurrentBinaryDirectory();
-  stampListFile += "/";
-  stampListFile += stampList;
-  std::string stampFile;
-  cmGeneratedFileStream fout(stampListFile.c_str());
-  for(std::vector<cmLocalGenerator*>::const_iterator
-        gi = generators.begin(); gi != generators.end(); ++gi)
-    {
-    stampFile = (*gi)->GetMakefile()->GetCurrentBinaryDirectory();
-    stampFile += "/";
-    stampFile += cmake::GetCMakeFilesDirectoryPostSlash();
-    stampFile += "generate.stamp";
-    fout << stampFile << "\n";
-    stamps.push_back(stampFile);
+    std::string stampListFile =
+      generators[0]->GetMakefile()->GetCurrentBinaryDirectory();
+    stampListFile += "/";
+    stampListFile += stampList;
+    std::string stampFile;
+    cmGeneratedFileStream fout(stampListFile.c_str());
+    for (std::vector<cmLocalGenerator*>::const_iterator gi =
+           generators.begin();
+         gi != generators.end(); ++gi) {
+      stampFile = (*gi)->GetMakefile()->GetCurrentBinaryDirectory();
+      stampFile += "/";
+      stampFile += cmake::GetCMakeFilesDirectoryPostSlash();
+      stampFile += "generate.stamp";
+      fout << stampFile << "\n";
+      stamps.push_back(stampFile);
     }
   }
 
   // Add a custom rule to re-run CMake if any input files changed.
   {
-  // Collect the input files used to generate all targets in this
-  // project.
-  std::vector<std::string> listFiles;
-  for(unsigned int j = 0; j < generators.size(); ++j)
-    {
-    cmMakefile* lmf = generators[j]->GetMakefile();
-    listFiles.insert(listFiles.end(), lmf->GetListFiles().begin(),
-                     lmf->GetListFiles().end());
-    }
-  // Sort the list of input files and remove duplicates.
-  std::sort(listFiles.begin(), listFiles.end(),
-            std::less<std::string>());
-  std::vector<std::string>::iterator new_end =
-    std::unique(listFiles.begin(), listFiles.end());
-  listFiles.erase(new_end, listFiles.end());
-
-  // Create a rule to re-run CMake.
-  std::string stampName = cmake::GetCMakeFilesDirectoryPostSlash();
-  stampName += "generate.stamp";
-  cmCustomCommandLine commandLine;
-  commandLine.push_back(cmSystemTools::GetCMakeCommand());
-  std::string argH = "-H";
-  argH += lg->GetSourceDirectory();
-  commandLine.push_back(argH);
-  std::string argB = "-B";
-  argB += lg->GetBinaryDirectory();
-  commandLine.push_back(argB);
-  commandLine.push_back("--check-stamp-list");
-  commandLine.push_back(stampList.c_str());
-  commandLine.push_back("--vs-solution-file");
-  commandLine.push_back("\"$(SolutionPath)\"");
-  cmCustomCommandLines commandLines;
-  commandLines.push_back(commandLine);
-
-  // Add the rule.  Note that we cannot use the CMakeLists.txt
-  // file as the main dependency because it would get
-  // overwritten by the CreateVCProjBuildRule.
-  // (this could be avoided with per-target source files)
-  std::string no_main_dependency = "";
-  std::vector<std::string> no_byproducts;
-  if(cmSourceFile* file =
-     mf->AddCustomCommandToOutput(
-       stamps, no_byproducts, listFiles,
-       no_main_dependency, commandLines, "Checking Build System",
-       no_working_directory, true))
-    {
-    gt->AddSource(file->GetFullPath());
+    // Collect the input files used to generate all targets in this
+    // project.
+    std::vector<std::string> listFiles;
+    for (unsigned int j = 0; j < generators.size(); ++j) {
+      cmMakefile* lmf = generators[j]->GetMakefile();
+      listFiles.insert(listFiles.end(), lmf->GetListFiles().begin(),
+                       lmf->GetListFiles().end());
     }
-  else
-    {
-    cmSystemTools::Error("Error adding rule for ", stamps[0].c_str());
+    // Sort the list of input files and remove duplicates.
+    std::sort(listFiles.begin(), listFiles.end(), std::less<std::string>());
+    std::vector<std::string>::iterator new_end =
+      std::unique(listFiles.begin(), listFiles.end());
+    listFiles.erase(new_end, listFiles.end());
+
+    // Create a rule to re-run CMake.
+    std::string stampName = cmake::GetCMakeFilesDirectoryPostSlash();
+    stampName += "generate.stamp";
+    cmCustomCommandLine commandLine;
+    commandLine.push_back(cmSystemTools::GetCMakeCommand());
+    std::string argH = "-H";
+    argH += lg->GetSourceDirectory();
+    commandLine.push_back(argH);
+    std::string argB = "-B";
+    argB += lg->GetBinaryDirectory();
+    commandLine.push_back(argB);
+    commandLine.push_back("--check-stamp-list");
+    commandLine.push_back(stampList.c_str());
+    commandLine.push_back("--vs-solution-file");
+    commandLine.push_back("\"$(SolutionPath)\"");
+    cmCustomCommandLines commandLines;
+    commandLines.push_back(commandLine);
+
+    // Add the rule.  Note that we cannot use the CMakeLists.txt
+    // file as the main dependency because it would get
+    // overwritten by the CreateVCProjBuildRule.
+    // (this could be avoided with per-target source files)
+    std::string no_main_dependency = "";
+    std::vector<std::string> no_byproducts;
+    if (cmSourceFile* file = mf->AddCustomCommandToOutput(
+          stamps, no_byproducts, listFiles, no_main_dependency, commandLines,
+          "Checking Build System", no_working_directory, true)) {
+      gt->AddSource(file->GetFullPath());
+    } else {
+      cmSystemTools::Error("Error adding rule for ", stamps[0].c_str());
     }
   }
 
@@ -351,83 +326,71 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget()
 void cmGlobalVisualStudio8Generator::AddExtraIDETargets()
 {
   cmGlobalVisualStudio7Generator::AddExtraIDETargets();
-  if(this->AddCheckTarget())
-    {
-    for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
-      {
+  if (this->AddCheckTarget()) {
+    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*>::iterator ti = tgts.begin();
-          ti != tgts.end(); ++ti)
-        {
-        if((*ti)->GetName() != CMAKE_CHECK_BUILD_SYSTEM_TARGET)
-          {
+      for (std::vector<cmGeneratorTarget*>::iterator ti = tgts.begin();
+           ti != tgts.end(); ++ti) {
+        if ((*ti)->GetName() != CMAKE_CHECK_BUILD_SYSTEM_TARGET) {
           (*ti)->Target->AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET);
-          }
         }
       }
     }
+  }
 }
 
-void
-cmGlobalVisualStudio8Generator
-::WriteSolutionConfigurations(std::ostream& fout,
-                              std::vector<std::string> const& configs)
+void cmGlobalVisualStudio8Generator::WriteSolutionConfigurations(
+  std::ostream& fout, std::vector<std::string> const& configs)
 {
   fout << "\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\n";
-  for(std::vector<std::string>::const_iterator i = configs.begin();
-      i != configs.end(); ++i)
-    {
-    fout << "\t\t" << *i << "|" << this->GetPlatformName()
-         << " = "  << *i << "|" << this->GetPlatformName() << "\n";
-    }
+  for (std::vector<std::string>::const_iterator i = configs.begin();
+       i != configs.end(); ++i) {
+    fout << "\t\t" << *i << "|" << this->GetPlatformName() << " = " << *i
+         << "|" << this->GetPlatformName() << "\n";
+  }
   fout << "\tEndGlobalSection\n";
 }
 
-void
-cmGlobalVisualStudio8Generator
-::WriteProjectConfigurations(
+void cmGlobalVisualStudio8Generator::WriteProjectConfigurations(
   std::ostream& fout, const std::string& name, cmState::TargetType type,
   std::vector<std::string> const& configs,
   const std::set<std::string>& configsPartOfDefaultBuild,
   std::string const& platformMapping)
 {
   std::string guid = this->GetGUID(name);
-  for(std::vector<std::string>::const_iterator i = configs.begin();
-      i != configs.end(); ++i)
-    {
-    fout << "\t\t{" << guid << "}." << *i
-         << "|" << this->GetPlatformName() << ".ActiveCfg = " << *i << "|"
-         << (!platformMapping.empty()?
-             platformMapping : this->GetPlatformName())
+  for (std::vector<std::string>::const_iterator i = configs.begin();
+       i != configs.end(); ++i) {
+    fout << "\t\t{" << guid << "}." << *i << "|" << this->GetPlatformName()
+         << ".ActiveCfg = " << *i << "|"
+         << (!platformMapping.empty() ? platformMapping
+                                      : this->GetPlatformName())
          << "\n";
-      std::set<std::string>::const_iterator
-        ci = configsPartOfDefaultBuild.find(*i);
-      if(!(ci == configsPartOfDefaultBuild.end()))
-      {
-      fout << "\t\t{" << guid << "}." << *i
-           << "|" << this->GetPlatformName() << ".Build.0 = " << *i << "|"
-           << (!platformMapping.empty()?
-               platformMapping : this->GetPlatformName())
+    std::set<std::string>::const_iterator ci =
+      configsPartOfDefaultBuild.find(*i);
+    if (!(ci == configsPartOfDefaultBuild.end())) {
+      fout << "\t\t{" << guid << "}." << *i << "|" << this->GetPlatformName()
+           << ".Build.0 = " << *i << "|"
+           << (!platformMapping.empty() ? platformMapping
+                                        : this->GetPlatformName())
            << "\n";
-      }
-    if(this->NeedsDeploy(type))
-      {
-      fout << "\t\t{" << guid << "}." << *i
-           << "|" << this->GetPlatformName() << ".Deploy.0 = " << *i << "|"
-           << (!platformMapping.empty()?
-               platformMapping : this->GetPlatformName())
+    }
+    if (this->NeedsDeploy(type)) {
+      fout << "\t\t{" << guid << "}." << *i << "|" << this->GetPlatformName()
+           << ".Deploy.0 = " << *i << "|"
+           << (!platformMapping.empty() ? platformMapping
+                                        : this->GetPlatformName())
            << "\n";
-      }
     }
+  }
 }
 
-bool
-cmGlobalVisualStudio8Generator::NeedsDeploy(cmState::TargetType type) const
+bool cmGlobalVisualStudio8Generator::NeedsDeploy(
+  cmState::TargetType type) const
 {
-  bool needsDeploy = (type == cmState::EXECUTABLE ||
-                      type == cmState::SHARED_LIBRARY);
+  bool needsDeploy =
+    (type == cmState::EXECUTABLE || type == cmState::SHARED_LIBRARY);
   return this->TargetsWindowsCE() && needsDeploy;
 }
 
@@ -440,80 +403,74 @@ bool cmGlobalVisualStudio8Generator::ComputeTargetDepends()
 
 void cmGlobalVisualStudio8Generator::WriteProjectDepends(
   std::ostream& fout, const std::string&, const char*,
-        cmGeneratorTarget const* gt)
+  cmGeneratorTarget const* gt)
 {
   TargetDependSet const& unordered = this->GetTargetDirectDepends(gt);
   OrderedTargetDependSet depends(unordered, std::string());
-  for(OrderedTargetDependSet::const_iterator i = depends.begin();
-      i != depends.end(); ++i)
-    {
-    if((*i)->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+  for (OrderedTargetDependSet::const_iterator i = depends.begin();
+       i != depends.end(); ++i) {
+    if ((*i)->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
     std::string guid = this->GetGUID((*i)->GetName().c_str());
     fout << "\t\t{" << guid << "} = {" << guid << "}\n";
-    }
+  }
 }
 
 bool cmGlobalVisualStudio8Generator::NeedLinkLibraryDependencies(
-        cmGeneratorTarget *target)
+  cmGeneratorTarget* target)
 {
   // Look for utility dependencies that magically link.
-  for(std::set<std::string>::const_iterator ui =
-        target->GetUtilities().begin();
-      ui != target->GetUtilities().end(); ++ui)
-    {
-    if(cmGeneratorTarget* depTarget =
-        target->GetLocalGenerator()->FindGeneratorTargetToUse(ui->c_str()))
-      {
-      if(depTarget->GetType() != cmState::INTERFACE_LIBRARY
-          && depTarget->GetProperty("EXTERNAL_MSPROJECT"))
-        {
+  for (std::set<std::string>::const_iterator ui =
+         target->GetUtilities().begin();
+       ui != target->GetUtilities().end(); ++ui) {
+    if (cmGeneratorTarget* depTarget =
+          target->GetLocalGenerator()->FindGeneratorTargetToUse(ui->c_str())) {
+      if (depTarget->GetType() != cmState::INTERFACE_LIBRARY &&
+          depTarget->GetProperty("EXTERNAL_MSPROJECT")) {
         // This utility dependency names an external .vcproj target.
         // We use LinkLibraryDependencies="true" to link to it without
         // predicting the .lib file location or name.
         return true;
-        }
       }
     }
+  }
   return false;
 }
 
-static cmVS7FlagTable cmVS8ExtraFlagTable[] =
-{
-  {"CallingConvention", "Gd", "cdecl", "0", 0 },
-  {"CallingConvention", "Gr", "fastcall", "1", 0 },
-  {"CallingConvention", "Gz", "stdcall", "2", 0 },
-
-  {"Detect64BitPortabilityProblems", "Wp64",
-   "Detect 64Bit Portability Problems", "true", 0 },
-  {"ErrorReporting", "errorReport:prompt", "Report immediately", "1", 0 },
-  {"ErrorReporting", "errorReport:queue", "Queue for next login", "2", 0 },
+static cmVS7FlagTable cmVS8ExtraFlagTable[] = {
+  { "CallingConvention", "Gd", "cdecl", "0", 0 },
+  { "CallingConvention", "Gr", "fastcall", "1", 0 },
+  { "CallingConvention", "Gz", "stdcall", "2", 0 },
+
+  { "Detect64BitPortabilityProblems", "Wp64",
+    "Detect 64Bit Portability Problems", "true", 0 },
+  { "ErrorReporting", "errorReport:prompt", "Report immediately", "1", 0 },
+  { "ErrorReporting", "errorReport:queue", "Queue for next login", "2", 0 },
   // Precompiled header and related options.  Note that the
   // UsePrecompiledHeader entries are marked as "Continue" so that the
   // corresponding PrecompiledHeaderThrough entry can be found.
-  {"UsePrecompiledHeader", "Yu", "Use Precompiled Header", "2",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"PrecompiledHeaderThrough", "Yu", "Precompiled Header Name", "",
-   cmVS7FlagTable::UserValueRequired},
+  { "UsePrecompiledHeader", "Yu", "Use Precompiled Header", "2",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "PrecompiledHeaderThrough", "Yu", "Precompiled Header Name", "",
+    cmVS7FlagTable::UserValueRequired },
   // There is no YX option in the VS8 IDE.
 
   // Exception handling mode.  If no entries match, it will be FALSE.
-  {"ExceptionHandling", "GX", "enable c++ exceptions", "1", 0},
-  {"ExceptionHandling", "EHsc", "enable c++ exceptions", "1", 0},
-  {"ExceptionHandling", "EHa", "enable SEH exceptions", "2", 0},
+  { "ExceptionHandling", "GX", "enable c++ exceptions", "1", 0 },
+  { "ExceptionHandling", "EHsc", "enable c++ exceptions", "1", 0 },
+  { "ExceptionHandling", "EHa", "enable SEH exceptions", "2", 0 },
 
-  {"EnablePREfast", "analyze", "", "true", 0},
-  {"EnablePREfast", "analyze-", "", "false", 0},
+  { "EnablePREfast", "analyze", "", "true", 0 },
+  { "EnablePREfast", "analyze-", "", "false", 0 },
 
   // Language options
-  {"TreatWChar_tAsBuiltInType", "Zc:wchar_t",
-   "wchar_t is a built-in type", "true", 0},
-  {"TreatWChar_tAsBuiltInType", "Zc:wchar_t-",
-   "wchar_t is not a built-in type", "false", 0},
+  { "TreatWChar_tAsBuiltInType", "Zc:wchar_t", "wchar_t is a built-in type",
+    "true", 0 },
+  { "TreatWChar_tAsBuiltInType", "Zc:wchar_t-",
+    "wchar_t is not a built-in type", "false", 0 },
 
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
 cmIDEFlagTable const* cmGlobalVisualStudio8Generator::GetExtraFlagTableVS8()
 {