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, 439 insertions, 646 deletions

diff --git a/Source/cmComputeLinkInformation.cxx b/Source/cmComputeLinkInformation.cxx
index 5b42b1a62c..e1a7bee305 100644
--- a/Source/cmComputeLinkInformation.cxx
+++ b/Source/cmComputeLinkInformation.cxx
@@ -240,45 +240,42 @@ because this need be done only for shared libraries without soname-s.
 
 */
 
-cmComputeLinkInformation
-::cmComputeLinkInformation(const cmGeneratorTarget* target,
-                           const std::string& config)
+cmComputeLinkInformation::cmComputeLinkInformation(
+  const cmGeneratorTarget* target, const std::string& config)
 {
   // Store context information.
   this->Target = target;
   this->Makefile = this->Target->Target->GetMakefile();
   this->GlobalGenerator =
-      this->Target->GetLocalGenerator()->GetGlobalGenerator();
+    this->Target->GetLocalGenerator()->GetGlobalGenerator();
   this->CMakeInstance = this->GlobalGenerator->GetCMakeInstance();
 
   // Check whether to recognize OpenBSD-style library versioned names.
-  this->OpenBSD = this->Makefile->GetState()
-            ->GetGlobalPropertyAsBool("FIND_LIBRARY_USE_OPENBSD_VERSIONING");
+  this->OpenBSD = this->Makefile->GetState()->GetGlobalPropertyAsBool(
+    "FIND_LIBRARY_USE_OPENBSD_VERSIONING");
 
   // The configuration being linked.
   this->Config = config;
 
   // Allocate internals.
-  this->OrderLinkerSearchPath =
-    new cmOrderDirectories(this->GlobalGenerator, target,
-                           "linker search path");
-  this->OrderRuntimeSearchPath =
-    new cmOrderDirectories(this->GlobalGenerator, target,
-                           "runtime search path");
+  this->OrderLinkerSearchPath = new cmOrderDirectories(
+    this->GlobalGenerator, target, "linker search path");
+  this->OrderRuntimeSearchPath = new cmOrderDirectories(
+    this->GlobalGenerator, target, "runtime search path");
   this->OrderDependentRPath = 0;
 
   // Get the language used for linking this target.
   this->LinkLanguage = this->Target->GetLinkerLanguage(config);
-  if(this->LinkLanguage.empty())
-    {
+  if (this->LinkLanguage.empty()) {
     // The Compute method will do nothing, so skip the rest of the
     // initialization.
     return;
-    }
+  }
 
   // Check whether we should use an import library for linking a target.
   this->UseImportLibrary =
-    this->Makefile->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")?true:false;
+    this->Makefile->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX") ? true
+                                                                 : false;
 
   // Check whether we should skip dependencies on shared library files.
   this->LinkDependsNoShared =
@@ -288,14 +285,13 @@ cmComputeLinkInformation
   // to use when creating a plugin (module) that obtains symbols from
   // the program that will load it.
   this->LoaderFlag = 0;
-  if(!this->UseImportLibrary &&
-     this->Target->GetType() == cmState::MODULE_LIBRARY)
-    {
+  if (!this->UseImportLibrary &&
+      this->Target->GetType() == cmState::MODULE_LIBRARY) {
     std::string loader_flag_var = "CMAKE_SHARED_MODULE_LOADER_";
     loader_flag_var += this->LinkLanguage;
     loader_flag_var += "_FLAG";
     this->LoaderFlag = this->Makefile->GetDefinition(loader_flag_var);
-    }
+  }
 
   // Get options needed to link libraries.
   this->LibLinkFlag =
@@ -307,11 +303,10 @@ cmComputeLinkInformation
 
   // Get options needed to specify RPATHs.
   this->RuntimeUseChrpath = false;
-  if(this->Target->GetType() != cmState::STATIC_LIBRARY)
-    {
+  if (this->Target->GetType() != cmState::STATIC_LIBRARY) {
     const char* tType =
-      ((this->Target->GetType() == cmState::EXECUTABLE)?
-       "EXECUTABLE" : "SHARED_LIBRARY");
+      ((this->Target->GetType() == cmState::EXECUTABLE) ? "EXECUTABLE"
+                                                        : "SHARED_LIBRARY");
     std::string rtVar = "CMAKE_";
     rtVar += tType;
     rtVar += "_RUNTIME_";
@@ -320,9 +315,8 @@ cmComputeLinkInformation
     std::string rtSepVar = rtVar + "_SEP";
     this->RuntimeFlag = this->Makefile->GetSafeDefinition(rtVar);
     this->RuntimeSep = this->Makefile->GetSafeDefinition(rtSepVar);
-    this->RuntimeAlways =
-      (this->Makefile->
-       GetSafeDefinition("CMAKE_PLATFORM_REQUIRED_RUNTIME_PATH"));
+    this->RuntimeAlways = (this->Makefile->GetSafeDefinition(
+      "CMAKE_PLATFORM_REQUIRED_RUNTIME_PATH"));
 
     this->RuntimeUseChrpath = this->Target->IsChrpathUsed(config);
 
@@ -333,14 +327,14 @@ cmComputeLinkInformation
     rlVar += this->LinkLanguage;
     rlVar += "_FLAG";
     this->RPathLinkFlag = this->Makefile->GetSafeDefinition(rlVar);
-    }
+  }
 
   // Check if we need to include the runtime search path at link time.
   {
-  std::string var = "CMAKE_SHARED_LIBRARY_LINK_";
-  var += this->LinkLanguage;
-  var += "_WITH_RUNTIME_PATH";
-  this->LinkWithRuntimePath = this->Makefile->IsOn(var);
+    std::string var = "CMAKE_SHARED_LIBRARY_LINK_";
+    var += this->LinkLanguage;
+    var += "_WITH_RUNTIME_PATH";
+    this->LinkWithRuntimePath = this->Makefile->IsOn(var);
   }
 
   // Check the platform policy for missing soname case.
@@ -358,41 +352,30 @@ cmComputeLinkInformation
 
   // Choose a mode for dealing with shared library dependencies.
   this->SharedDependencyMode = SharedDepModeNone;
-  if(this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_FILES"))
-    {
+  if (this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_FILES")) {
     this->SharedDependencyMode = SharedDepModeLink;
-    }
-  else if(this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_DIRS"))
-    {
+  } else if (this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_DIRS")) {
     this->SharedDependencyMode = SharedDepModeLibDir;
-    }
-  else if(!this->RPathLinkFlag.empty())
-    {
+  } else if (!this->RPathLinkFlag.empty()) {
     this->SharedDependencyMode = SharedDepModeDir;
-    this->OrderDependentRPath =
-      new cmOrderDirectories(this->GlobalGenerator, target,
-                             "dependent library path");
-    }
+    this->OrderDependentRPath = new cmOrderDirectories(
+      this->GlobalGenerator, target, "dependent library path");
+  }
 
   // Add the search path entries requested by the user to path ordering.
-  this->OrderLinkerSearchPath
-    ->AddUserDirectories(this->Target->GetLinkDirectories());
-  this->OrderRuntimeSearchPath
-    ->AddUserDirectories(this->Target->GetLinkDirectories());
+  this->OrderLinkerSearchPath->AddUserDirectories(
+    this->Target->GetLinkDirectories());
+  this->OrderRuntimeSearchPath->AddUserDirectories(
+    this->Target->GetLinkDirectories());
 
   // Set up the implicit link directories.
   this->LoadImplicitLinkInfo();
-  this->OrderLinkerSearchPath
-    ->SetImplicitDirectories(this->ImplicitLinkDirs);
-  this->OrderRuntimeSearchPath
-    ->SetImplicitDirectories(this->ImplicitLinkDirs);
-  if(this->OrderDependentRPath)
-    {
-    this->OrderDependentRPath
-      ->SetImplicitDirectories(this->ImplicitLinkDirs);
-    this->OrderDependentRPath
-      ->AddLanguageDirectories(this->RuntimeLinkDirs);
-    }
+  this->OrderLinkerSearchPath->SetImplicitDirectories(this->ImplicitLinkDirs);
+  this->OrderRuntimeSearchPath->SetImplicitDirectories(this->ImplicitLinkDirs);
+  if (this->OrderDependentRPath) {
+    this->OrderDependentRPath->SetImplicitDirectories(this->ImplicitLinkDirs);
+    this->OrderDependentRPath->AddLanguageDirectories(this->RuntimeLinkDirs);
+  }
 
   // Decide whether to enable compatible library search path mode.
   // There exists code that effectively does
@@ -407,18 +390,15 @@ cmComputeLinkInformation
   // containing libraries linked with a full path to the -L path.
   this->OldLinkDirMode =
     this->Target->GetPolicyStatusCMP0003() != cmPolicies::NEW;
-  if(this->OldLinkDirMode)
-    {
+  if (this->OldLinkDirMode) {
     // Construct a mask to not bother with this behavior for link
     // directories already specified by the user.
-    std::vector<std::string> const& dirs =
-        this->Target->GetLinkDirectories();
+    std::vector<std::string> const& dirs = this->Target->GetLinkDirectories();
     this->OldLinkDirMask.insert(dirs.begin(), dirs.end());
-    }
+  }
 
-  this->CMP0060Warn =
-    this->Makefile->PolicyOptionalWarningEnabled(
-      "CMAKE_POLICY_WARNING_CMP0060");
+  this->CMP0060Warn = this->Makefile->PolicyOptionalWarningEnabled(
+    "CMAKE_POLICY_WARNING_CMP0060");
 }
 
 cmComputeLinkInformation::~cmComputeLinkInformation()
@@ -443,10 +423,9 @@ std::string cmComputeLinkInformation::GetRPathLinkString()
 {
   // If there is no separate linker runtime search flag (-rpath-link)
   // there is no reason to compute a string.
-  if(!this->OrderDependentRPath)
-    {
+  if (!this->OrderDependentRPath) {
     return "";
-    }
+  }
 
   // Construct the linker runtime search path.
   return cmJoin(this->OrderDependentRPath->GetOrderedDirectories(), ":");
@@ -471,22 +450,20 @@ cmComputeLinkInformation::GetSharedLibrariesLinked()
 bool cmComputeLinkInformation::Compute()
 {
   // Skip targets that do not link.
-  if(!(this->Target->GetType() == cmState::EXECUTABLE ||
-       this->Target->GetType() == cmState::SHARED_LIBRARY ||
-       this->Target->GetType() == cmState::MODULE_LIBRARY ||
-       this->Target->GetType() == cmState::STATIC_LIBRARY))
-    {
+  if (!(this->Target->GetType() == cmState::EXECUTABLE ||
+        this->Target->GetType() == cmState::SHARED_LIBRARY ||
+        this->Target->GetType() == cmState::MODULE_LIBRARY ||
+        this->Target->GetType() == cmState::STATIC_LIBRARY)) {
     return false;
-    }
+  }
 
   // We require a link language for the target.
-  if(this->LinkLanguage.empty())
-    {
-    cmSystemTools::
-      Error("CMake can not determine linker language for target: ",
-            this->Target->GetName().c_str());
+  if (this->LinkLanguage.empty()) {
+    cmSystemTools::Error(
+      "CMake can not determine linker language for target: ",
+      this->Target->GetName().c_str());
     return false;
-    }
+  }
 
   // Compute the ordered link line items.
   cmComputeLinkDepends cld(this->Target, this->Config);
@@ -494,64 +471,52 @@ bool cmComputeLinkInformation::Compute()
   cmComputeLinkDepends::EntryVector const& linkEntries = cld.Compute();
 
   // Add the link line items.
-  for(cmComputeLinkDepends::EntryVector::const_iterator
-        lei = linkEntries.begin();
-      lei != linkEntries.end(); ++lei)
-    {
-    if(lei->IsSharedDep)
-      {
+  for (cmComputeLinkDepends::EntryVector::const_iterator lei =
+         linkEntries.begin();
+       lei != linkEntries.end(); ++lei) {
+    if (lei->IsSharedDep) {
       this->AddSharedDepItem(lei->Item, lei->Target);
-      }
-    else
-      {
+    } else {
       this->AddItem(lei->Item, lei->Target);
-      }
     }
+  }
 
   // Restore the target link type so the correct system runtime
   // libraries are found.
-  const char* lss =
-      this->Target->GetProperty("LINK_SEARCH_END_STATIC");
-  if(cmSystemTools::IsOn(lss))
-    {
+  const char* lss = this->Target->GetProperty("LINK_SEARCH_END_STATIC");
+  if (cmSystemTools::IsOn(lss)) {
     this->SetCurrentLinkType(LinkStatic);
-    }
-  else
-    {
+  } else {
     this->SetCurrentLinkType(this->StartLinkType);
-    }
+  }
 
   // Finish listing compatibility paths.
-  if(this->OldLinkDirMode)
-    {
+  if (this->OldLinkDirMode) {
     // For CMake 2.4 bug-compatibility we need to consider the output
     // directories of targets linked in another configuration as link
     // directories.
     std::set<cmGeneratorTarget const*> const& wrongItems =
-        cld.GetOldWrongConfigItems();
-    for(std::set<cmGeneratorTarget const*>::const_iterator i =
-        wrongItems.begin(); i != wrongItems.end(); ++i)
-      {
+      cld.GetOldWrongConfigItems();
+    for (std::set<cmGeneratorTarget const*>::const_iterator i =
+           wrongItems.begin();
+         i != wrongItems.end(); ++i) {
       cmGeneratorTarget const* tgt = *i;
-      bool implib =
-        (this->UseImportLibrary &&
-         (tgt->GetType() == cmState::SHARED_LIBRARY));
-      std::string lib = tgt->GetFullPath(this->Config , implib, true);
+      bool implib = (this->UseImportLibrary &&
+                     (tgt->GetType() == cmState::SHARED_LIBRARY));
+      std::string lib = tgt->GetFullPath(this->Config, implib, true);
       this->OldLinkDirItems.push_back(lib);
-      }
     }
+  }
 
   // Finish setting up linker search directories.
-  if(!this->FinishLinkerSearchDirectories())
-    {
+  if (!this->FinishLinkerSearchDirectories()) {
     return false;
-    }
+  }
 
   // Add implicit language runtime libraries and directories.
   this->AddImplicitLinkInfo();
 
-  if (!this->CMP0060WarnItems.empty())
-    {
+  if (!this->CMP0060WarnItems.empty()) {
     std::ostringstream w;
     /* clang-format off */
     w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0060) << "\n"
@@ -565,7 +530,7 @@ bool cmComputeLinkInformation::Compute()
     /* clang-format on */
     this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
                                       this->Target->GetBacktrace());
-    }
+  }
 
   return true;
 }
@@ -574,16 +539,14 @@ void cmComputeLinkInformation::AddImplicitLinkInfo()
 {
   // The link closure lists all languages whose implicit info is needed.
   cmGeneratorTarget::LinkClosure const* lc =
-      this->Target->GetLinkClosure(this->Config);
-  for(std::vector<std::string>::const_iterator li = lc->Languages.begin();
-      li != lc->Languages.end(); ++li)
-    {
+    this->Target->GetLinkClosure(this->Config);
+  for (std::vector<std::string>::const_iterator li = lc->Languages.begin();
+       li != lc->Languages.end(); ++li) {
     // Skip those of the linker language.  They are implicit.
-    if(*li != this->LinkLanguage)
-      {
+    if (*li != this->LinkLanguage) {
       this->AddImplicitLinkInfo(*li);
-      }
     }
+  }
 }
 
 void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang)
@@ -593,31 +556,27 @@ void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang)
   std::string libVar = "CMAKE_";
   libVar += lang;
   libVar += "_IMPLICIT_LINK_LIBRARIES";
-  if(const char* libs = this->Makefile->GetDefinition(libVar))
-    {
+  if (const char* libs = this->Makefile->GetDefinition(libVar)) {
     std::vector<std::string> libsVec;
     cmSystemTools::ExpandListArgument(libs, libsVec);
-    for(std::vector<std::string>::const_iterator i = libsVec.begin();
-        i != libsVec.end(); ++i)
-      {
-      if(this->ImplicitLinkLibs.find(*i) == this->ImplicitLinkLibs.end())
-        {
+    for (std::vector<std::string>::const_iterator i = libsVec.begin();
+         i != libsVec.end(); ++i) {
+      if (this->ImplicitLinkLibs.find(*i) == this->ImplicitLinkLibs.end()) {
         this->AddItem(*i, 0);
-        }
       }
     }
+  }
 
   // Add linker search paths for this language that are not
   // implied by the linker language.
   std::string dirVar = "CMAKE_";
   dirVar += lang;
   dirVar += "_IMPLICIT_LINK_DIRECTORIES";
-  if(const char* dirs = this->Makefile->GetDefinition(dirVar))
-    {
+  if (const char* dirs = this->Makefile->GetDefinition(dirVar)) {
     std::vector<std::string> dirsVec;
     cmSystemTools::ExpandListArgument(dirs, dirsVec);
     this->OrderLinkerSearchPath->AddLanguageDirectories(dirsVec);
-    }
+  }
 }
 
 void cmComputeLinkInformation::AddItem(std::string const& item,
@@ -626,176 +585,141 @@ void cmComputeLinkInformation::AddItem(std::string const& item,
   // Compute the proper name to use to link this library.
   const std::string& config = this->Config;
   bool impexe = (tgt && tgt->IsExecutableWithExports());
-  if(impexe && !this->UseImportLibrary && !this->LoaderFlag)
-    {
+  if (impexe && !this->UseImportLibrary && !this->LoaderFlag) {
     // Skip linking to executables on platforms with no import
     // libraries or loader flags.
     return;
-    }
+  }
 
-  if(tgt && tgt->IsLinkable())
-    {
+  if (tgt && tgt->IsLinkable()) {
     // This is a CMake target.  Ask the target for its real name.
-    if(impexe && this->LoaderFlag)
-      {
+    if (impexe && this->LoaderFlag) {
       // This link item is an executable that may provide symbols
       // used by this target.  A special flag is needed on this
       // platform.  Add it now.
       std::string linkItem;
       linkItem = this->LoaderFlag;
 
-      std::string exe = tgt->GetFullPath(config, this->UseImportLibrary,
-                                         true);
+      std::string exe = tgt->GetFullPath(config, this->UseImportLibrary, true);
       linkItem += exe;
       this->Items.push_back(Item(linkItem, true, tgt));
       this->Depends.push_back(exe);
-      }
-    else if(tgt->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    } else if (tgt->GetType() == cmState::INTERFACE_LIBRARY) {
       // Add the interface library as an item so it can be considered as part
       // of COMPATIBLE_INTERFACE_ enforcement.  The generators will ignore
       // this for the actual link line.
       this->Items.push_back(Item(std::string(), false, tgt));
-      }
-    else
-      {
+    } else {
       // Decide whether to use an import library.
-      bool implib =
-        (this->UseImportLibrary &&
-         (impexe || tgt->GetType() == cmState::SHARED_LIBRARY));
+      bool implib = (this->UseImportLibrary &&
+                     (impexe || tgt->GetType() == cmState::SHARED_LIBRARY));
 
       // Pass the full path to the target file.
       std::string lib = tgt->GetFullPath(config, implib, true);
-      if(!this->LinkDependsNoShared ||
-         tgt->GetType() != cmState::SHARED_LIBRARY)
-        {
+      if (!this->LinkDependsNoShared ||
+          tgt->GetType() != cmState::SHARED_LIBRARY) {
         this->Depends.push_back(lib);
-        }
+      }
 
       this->AddTargetItem(lib, tgt);
       this->AddLibraryRuntimeInfo(lib, tgt);
-      }
     }
-  else
-    {
+  } else {
     // This is not a CMake target.  Use the name given.
-    if(cmSystemTools::FileIsFullPath(item.c_str()))
-      {
-      if(cmSystemTools::FileIsDirectory(item))
-        {
+    if (cmSystemTools::FileIsFullPath(item.c_str())) {
+      if (cmSystemTools::FileIsDirectory(item)) {
         // This is a directory.
         this->AddDirectoryItem(item);
-        }
-      else
-        {
+      } else {
         // Use the full path given to the library file.
         this->Depends.push_back(item);
         this->AddFullItem(item);
         this->AddLibraryRuntimeInfo(item);
-        }
       }
-    else
-      {
+    } else {
       // This is a library or option specified by the user.
       this->AddUserItem(item, true);
-      }
     }
+  }
 }
 
 void cmComputeLinkInformation::AddSharedDepItem(std::string const& item,
                                                 const cmGeneratorTarget* tgt)
 {
   // If dropping shared library dependencies, ignore them.
-  if(this->SharedDependencyMode == SharedDepModeNone)
-    {
+  if (this->SharedDependencyMode == SharedDepModeNone) {
     return;
-    }
+  }
 
   // The user may have incorrectly named an item.  Skip items that are
   // not full paths to shared libraries.
-  if(tgt)
-    {
+  if (tgt) {
     // The target will provide a full path.  Make sure it is a shared
     // library.
-    if(tgt->GetType() != cmState::SHARED_LIBRARY)
-      {
+    if (tgt->GetType() != cmState::SHARED_LIBRARY) {
       return;
-      }
     }
-  else
-    {
+  } else {
     // Skip items that are not full paths.  We will not be able to
     // reliably specify them.
-    if(!cmSystemTools::FileIsFullPath(item.c_str()))
-      {
+    if (!cmSystemTools::FileIsFullPath(item.c_str())) {
       return;
-      }
+    }
 
     // Get the name of the library from the file name.
     std::string file = cmSystemTools::GetFilenameName(item);
-    if(!this->ExtractSharedLibraryName.find(file.c_str()))
-      {
+    if (!this->ExtractSharedLibraryName.find(file.c_str())) {
       // This is not the name of a shared library.
       return;
-      }
     }
+  }
 
   // If in linking mode, just link to the shared library.
-  if(this->SharedDependencyMode == SharedDepModeLink)
-    {
+  if (this->SharedDependencyMode == SharedDepModeLink) {
     this->AddItem(item, tgt);
     return;
-    }
+  }
 
   // Get a full path to the dependent shared library.
   // Add it to the runtime path computation so that the target being
   // linked will be able to find it.
   std::string lib;
-  if(tgt)
-    {
+  if (tgt) {
     lib = tgt->GetFullPath(this->Config, this->UseImportLibrary);
     this->AddLibraryRuntimeInfo(lib, tgt);
-    }
-  else
-    {
+  } else {
     lib = item;
     this->AddLibraryRuntimeInfo(lib);
-    }
+  }
 
   // Check if we need to include the dependent shared library in other
   // path ordering.
   cmOrderDirectories* order = 0;
-  if(this->SharedDependencyMode == SharedDepModeLibDir &&
-     !this->LinkWithRuntimePath /* AddLibraryRuntimeInfo adds it */)
-    {
+  if (this->SharedDependencyMode == SharedDepModeLibDir &&
+      !this->LinkWithRuntimePath /* AddLibraryRuntimeInfo adds it */) {
     // Add the item to the linker search path.
     order = this->OrderLinkerSearchPath;
-    }
-  else if(this->SharedDependencyMode == SharedDepModeDir)
-    {
+  } else if (this->SharedDependencyMode == SharedDepModeDir) {
     // Add the item to the separate dependent library search path.
     order = this->OrderDependentRPath;
-    }
-  if(order)
-    {
-    if(tgt)
-      {
+  }
+  if (order) {
+    if (tgt) {
       std::string soName = tgt->GetSOName(this->Config);
-      const char* soname = soName.empty()? 0 : soName.c_str();
+      const char* soname = soName.empty() ? 0 : soName.c_str();
       order->AddRuntimeLibrary(lib, soname);
-      }
-    else
-      {
+    } else {
       order->AddRuntimeLibrary(lib);
-      }
     }
+  }
 }
 
 void cmComputeLinkInformation::ComputeLinkTypeInfo()
 {
   // Check whether archives may actually be shared libraries.
-  this->ArchivesMayBeShared = this->CMakeInstance->GetState()
-              ->GetGlobalPropertyAsBool("TARGET_ARCHIVES_MAY_BE_SHARED_LIBS");
+  this->ArchivesMayBeShared =
+    this->CMakeInstance->GetState()->GetGlobalPropertyAsBool(
+      "TARGET_ARCHIVES_MAY_BE_SHARED_LIBS");
 
   // First assume we cannot do link type stuff.
   this->LinkTypeEnabled = false;
@@ -804,15 +728,20 @@ void cmComputeLinkInformation::ComputeLinkTypeInfo()
   const char* static_link_type_flag = 0;
   const char* shared_link_type_flag = 0;
   const char* target_type_str = 0;
-  switch(this->Target->GetType())
-    {
-    case cmState::EXECUTABLE:     target_type_str = "EXE"; break;
-    case cmState::SHARED_LIBRARY: target_type_str = "SHARED_LIBRARY"; break;
-    case cmState::MODULE_LIBRARY: target_type_str = "SHARED_MODULE"; break;
-    default: break;
-    }
-  if(target_type_str)
-    {
+  switch (this->Target->GetType()) {
+    case cmState::EXECUTABLE:
+      target_type_str = "EXE";
+      break;
+    case cmState::SHARED_LIBRARY:
+      target_type_str = "SHARED_LIBRARY";
+      break;
+    case cmState::MODULE_LIBRARY:
+      target_type_str = "SHARED_MODULE";
+      break;
+    default:
+      break;
+  }
+  if (target_type_str) {
     std::string static_link_type_flag_var = "CMAKE_";
     static_link_type_flag_var += target_type_str;
     static_link_type_flag_var += "_LINK_STATIC_";
@@ -828,22 +757,20 @@ void cmComputeLinkInformation::ComputeLinkTypeInfo()
     shared_link_type_flag_var += "_FLAGS";
     shared_link_type_flag =
       this->Makefile->GetDefinition(shared_link_type_flag_var);
-    }
+  }
 
   // We can support link type switching only if all needed flags are
   // known.
-  if(static_link_type_flag && *static_link_type_flag &&
-     shared_link_type_flag && *shared_link_type_flag)
-    {
+  if (static_link_type_flag && *static_link_type_flag &&
+      shared_link_type_flag && *shared_link_type_flag) {
     this->LinkTypeEnabled = true;
     this->StaticLinkTypeFlag = static_link_type_flag;
     this->SharedLinkTypeFlag = shared_link_type_flag;
-    }
+  }
 
   // Lookup the starting link type from the target (linked statically?).
-  const char* lss =
-      this->Target->GetProperty("LINK_SEARCH_START_STATIC");
-  this->StartLinkType = cmSystemTools::IsOn(lss)? LinkStatic : LinkShared;
+  const char* lss = this->Target->GetProperty("LINK_SEARCH_START_STATIC");
+  this->StartLinkType = cmSystemTools::IsOn(lss) ? LinkStatic : LinkShared;
   this->CurrentLinkType = this->StartLinkType;
 }
 
@@ -864,50 +791,44 @@ void cmComputeLinkInformation::ComputeItemParserInfo()
                          LinkShared);
   this->AddLinkExtension(mf->GetDefinition("CMAKE_LINK_LIBRARY_SUFFIX"),
                          LinkUnknown);
-  if(const char* linkSuffixes =
-     mf->GetDefinition("CMAKE_EXTRA_LINK_EXTENSIONS"))
-    {
+  if (const char* linkSuffixes =
+        mf->GetDefinition("CMAKE_EXTRA_LINK_EXTENSIONS")) {
     std::vector<std::string> linkSuffixVec;
     cmSystemTools::ExpandListArgument(linkSuffixes, linkSuffixVec);
-    for(std::vector<std::string>::iterator i = linkSuffixVec.begin();
-        i != linkSuffixVec.end(); ++i)
-      {
+    for (std::vector<std::string>::iterator i = linkSuffixVec.begin();
+         i != linkSuffixVec.end(); ++i) {
       this->AddLinkExtension(i->c_str(), LinkUnknown);
-      }
     }
-  if(const char* sharedSuffixes =
-     mf->GetDefinition("CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES"))
-    {
+  }
+  if (const char* sharedSuffixes =
+        mf->GetDefinition("CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES")) {
     std::vector<std::string> sharedSuffixVec;
     cmSystemTools::ExpandListArgument(sharedSuffixes, sharedSuffixVec);
-    for(std::vector<std::string>::iterator i = sharedSuffixVec.begin();
-        i != sharedSuffixVec.end(); ++i)
-      {
+    for (std::vector<std::string>::iterator i = sharedSuffixVec.begin();
+         i != sharedSuffixVec.end(); ++i) {
       this->AddLinkExtension(i->c_str(), LinkShared);
-      }
     }
+  }
 
   // Compute a regex to match link extensions.
-  std::string libext = this->CreateExtensionRegex(this->LinkExtensions,
-                                                  LinkUnknown);
+  std::string libext =
+    this->CreateExtensionRegex(this->LinkExtensions, LinkUnknown);
 
   // Create regex to remove any library extension.
   std::string reg("(.*)");
   reg += libext;
-  this->OrderLinkerSearchPath->SetLinkExtensionInfo(this->LinkExtensions,
-                                                    reg);
+  this->OrderLinkerSearchPath->SetLinkExtensionInfo(this->LinkExtensions, reg);
 
   // Create a regex to match a library name.  Match index 1 will be
   // the prefix if it exists and empty otherwise.  Match index 2 will
   // be the library name.  Match index 3 will be the library
   // extension.
   reg = "^(";
-  for(std::set<std::string>::iterator p = this->LinkPrefixes.begin();
-      p != this->LinkPrefixes.end(); ++p)
-    {
+  for (std::set<std::string>::iterator p = this->LinkPrefixes.begin();
+       p != this->LinkPrefixes.end(); ++p) {
     reg += *p;
     reg += "|";
-    }
+  }
   reg += ")";
   reg += "([^/:]*)";
 
@@ -920,65 +841,57 @@ void cmComputeLinkInformation::ComputeItemParserInfo()
   this->ExtractAnyLibraryName.compile(reg_any.c_str());
 
   // Create a regex to match static library names.
-  if(!this->StaticLinkExtensions.empty())
-    {
+  if (!this->StaticLinkExtensions.empty()) {
     std::string reg_static = reg;
-    reg_static += this->CreateExtensionRegex(this->StaticLinkExtensions,
-                                             LinkStatic);
+    reg_static +=
+      this->CreateExtensionRegex(this->StaticLinkExtensions, LinkStatic);
 #ifdef CM_COMPUTE_LINK_INFO_DEBUG
-  fprintf(stderr, "static regex [%s]\n", reg_static.c_str());
+    fprintf(stderr, "static regex [%s]\n", reg_static.c_str());
 #endif
     this->ExtractStaticLibraryName.compile(reg_static.c_str());
-    }
+  }
 
   // Create a regex to match shared library names.
-  if(!this->SharedLinkExtensions.empty())
-    {
+  if (!this->SharedLinkExtensions.empty()) {
     std::string reg_shared = reg;
     this->SharedRegexString =
       this->CreateExtensionRegex(this->SharedLinkExtensions, LinkShared);
     reg_shared += this->SharedRegexString;
 #ifdef CM_COMPUTE_LINK_INFO_DEBUG
-  fprintf(stderr, "shared regex [%s]\n", reg_shared.c_str());
+    fprintf(stderr, "shared regex [%s]\n", reg_shared.c_str());
 #endif
     this->ExtractSharedLibraryName.compile(reg_shared.c_str());
-    }
+  }
 }
 
 void cmComputeLinkInformation::AddLinkPrefix(const char* p)
 {
-  if(p && *p)
-    {
+  if (p && *p) {
     this->LinkPrefixes.insert(p);
-    }
+  }
 }
 
 void cmComputeLinkInformation::AddLinkExtension(const char* e, LinkType type)
 {
-  if(e && *e)
-    {
-    if(type == LinkStatic)
-      {
+  if (e && *e) {
+    if (type == LinkStatic) {
       this->StaticLinkExtensions.push_back(e);
-      }
-    if(type == LinkShared)
-      {
+    }
+    if (type == LinkShared) {
       this->SharedLinkExtensions.push_back(e);
-      }
-    this->LinkExtensions.push_back(e);
     }
+    this->LinkExtensions.push_back(e);
+  }
 }
 
-std::string
-cmComputeLinkInformation
-::CreateExtensionRegex(std::vector<std::string> const& exts, LinkType type)
+std::string cmComputeLinkInformation::CreateExtensionRegex(
+  std::vector<std::string> const& exts, LinkType type)
 {
   // Build a list of extension choices.
   std::string libext = "(";
   const char* sep = "";
-  for(std::vector<std::string>::const_iterator i = exts.begin();
-      i != exts.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = exts.begin();
+       i != exts.end(); ++i) {
     // Separate this choice from the previous one.
     libext += sep;
     sep = "|";
@@ -990,20 +903,17 @@ cmComputeLinkInformation
 #else
     libext += *i;
 #endif
-    }
+  }
 
   // Finish the list.
   libext += ")";
 
   // Add an optional OpenBSD version component.
-  if(this->OpenBSD)
-    {
+  if (this->OpenBSD) {
     libext += "(\\.[0-9]+\\.[0-9]+)?";
-    }
-  else if(type == LinkShared)
-    {
+  } else if (type == LinkShared) {
     libext += "(\\.[0-9]+)?";
-    }
+  }
 
   libext += "$";
   return libext;
@@ -1013,21 +923,17 @@ std::string cmComputeLinkInformation::NoCaseExpression(const char* str)
 {
   std::string ret;
   const char* s = str;
-  while(*s)
-    {
-    if(*s == '.')
-      {
+  while (*s) {
+    if (*s == '.') {
       ret += *s;
-      }
-    else
-      {
+    } else {
       ret += "[";
       ret += static_cast<char>(tolower(*s));
       ret += static_cast<char>(toupper(*s));
       ret += "]";
-      }
-    s++;
     }
+    s++;
+  }
   return ret;
 }
 
@@ -1035,14 +941,11 @@ void cmComputeLinkInformation::SetCurrentLinkType(LinkType lt)
 {
   // If we are changing the current link type add the flag to tell the
   // linker about it.
-  if(this->CurrentLinkType != lt)
-    {
+  if (this->CurrentLinkType != lt) {
     this->CurrentLinkType = lt;
 
-    if(this->LinkTypeEnabled)
-      {
-      switch(this->CurrentLinkType)
-        {
+    if (this->LinkTypeEnabled) {
+      switch (this->CurrentLinkType) {
         case LinkStatic:
           this->Items.push_back(Item(this->StaticLinkTypeFlag, false));
           break;
@@ -1051,9 +954,9 @@ void cmComputeLinkInformation::SetCurrentLinkType(LinkType lt)
           break;
         default:
           break;
-        }
       }
     }
+  }
 }
 
 void cmComputeLinkInformation::AddTargetItem(std::string const& item,
@@ -1065,39 +968,34 @@ void cmComputeLinkInformation::AddTargetItem(std::string const& item,
   // shared and static libraries but static-mode can handle only
   // static libraries.  If a previous user item changed the link type
   // to static we need to make sure it is back to shared.
-  if(target->GetType() != cmState::STATIC_LIBRARY)
-    {
+  if (target->GetType() != cmState::STATIC_LIBRARY) {
     this->SetCurrentLinkType(LinkShared);
-    }
+  }
 
   // Keep track of shared library targets linked.
-  if(target->GetType() == cmState::SHARED_LIBRARY)
-    {
+  if (target->GetType() == cmState::SHARED_LIBRARY) {
     this->SharedLibrariesLinked.insert(target);
-    }
+  }
 
   // Handle case of an imported shared library with no soname.
-  if(this->NoSONameUsesPath &&
-     target->IsImportedSharedLibWithoutSOName(this->Config))
-    {
+  if (this->NoSONameUsesPath &&
+      target->IsImportedSharedLibWithoutSOName(this->Config)) {
     this->AddSharedLibNoSOName(item);
     return;
-    }
+  }
 
   // If this platform wants a flag before the full path, add it.
-  if(!this->LibLinkFileFlag.empty())
-    {
+  if (!this->LibLinkFileFlag.empty()) {
     this->Items.push_back(Item(this->LibLinkFileFlag, false));
-    }
+  }
 
   // For compatibility with CMake 2.4 include the item's directory in
   // the linker search path.
-  if(this->OldLinkDirMode && !target->IsFrameworkOnApple() &&
-     this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) ==
-     this->OldLinkDirMask.end())
-    {
+  if (this->OldLinkDirMode && !target->IsFrameworkOnApple() &&
+      this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) ==
+        this->OldLinkDirMask.end()) {
     this->OldLinkDirItems.push_back(item);
-    }
+  }
 
   // Now add the full path to the library.
   this->Items.push_back(Item(item, true, target));
@@ -1106,31 +1004,27 @@ void cmComputeLinkInformation::AddTargetItem(std::string const& item,
 void cmComputeLinkInformation::AddFullItem(std::string const& item)
 {
   // Check for the implicit link directory special case.
-  if(this->CheckImplicitDirItem(item))
-    {
+  if (this->CheckImplicitDirItem(item)) {
     return;
-    }
+  }
 
   // Check for case of shared library with no builtin soname.
-  if(this->NoSONameUsesPath && this->CheckSharedLibNoSOName(item))
-    {
+  if (this->NoSONameUsesPath && this->CheckSharedLibNoSOName(item)) {
     return;
-    }
+  }
 
   // Full path libraries should specify a valid library file name.
   // See documentation of CMP0008.
   std::string generator = this->GlobalGenerator->GetName();
-  if(this->Target->GetPolicyStatusCMP0008() != cmPolicies::NEW &&
-     (generator.find("Visual Studio") != generator.npos ||
-      generator.find("Xcode") != generator.npos))
-    {
+  if (this->Target->GetPolicyStatusCMP0008() != cmPolicies::NEW &&
+      (generator.find("Visual Studio") != generator.npos ||
+       generator.find("Xcode") != generator.npos)) {
     std::string file = cmSystemTools::GetFilenameName(item);
-    if(!this->ExtractAnyLibraryName.find(file.c_str()))
-      {
+    if (!this->ExtractAnyLibraryName.find(file.c_str())) {
       this->HandleBadFullItem(item, file);
       return;
-      }
     }
+  }
 
   // This is called to handle a link item that is a full path.
   // If the target is not a static library make sure the link type is
@@ -1138,35 +1032,29 @@ void cmComputeLinkInformation::AddFullItem(std::string const& item)
   // shared and static libraries but static-mode can handle only
   // static libraries.  If a previous user item changed the link type
   // to static we need to make sure it is back to shared.
-  if(this->LinkTypeEnabled)
-    {
+  if (this->LinkTypeEnabled) {
     std::string name = cmSystemTools::GetFilenameName(item);
-    if(this->ExtractSharedLibraryName.find(name))
-      {
+    if (this->ExtractSharedLibraryName.find(name)) {
       this->SetCurrentLinkType(LinkShared);
-      }
-    else if(!this->ExtractStaticLibraryName.find(item))
-      {
+    } else if (!this->ExtractStaticLibraryName.find(item)) {
       // We cannot determine the type.  Assume it is the target's
       // default type.
       this->SetCurrentLinkType(this->StartLinkType);
-      }
     }
+  }
 
   // For compatibility with CMake 2.4 include the item's directory in
   // the linker search path.
-  if(this->OldLinkDirMode &&
-     this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) ==
-     this->OldLinkDirMask.end())
-    {
+  if (this->OldLinkDirMode &&
+      this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) ==
+        this->OldLinkDirMask.end()) {
     this->OldLinkDirItems.push_back(item);
-    }
+  }
 
   // If this platform wants a flag before the full path, add it.
-  if(!this->LibLinkFileFlag.empty())
-    {
+  if (!this->LibLinkFileFlag.empty()) {
     this->Items.push_back(Item(this->LibLinkFileFlag, false));
-    }
+  }
 
   // Now add the full path to the library.
   this->Items.push_back(Item(item, true));
@@ -1177,49 +1065,43 @@ bool cmComputeLinkInformation::CheckImplicitDirItem(std::string const& item)
   // We only switch to a pathless item if the link type may be
   // enforced.  Fortunately only platforms that support link types
   // seem to have magic per-architecture implicit link directories.
-  if(!this->LinkTypeEnabled)
-    {
+  if (!this->LinkTypeEnabled) {
     return false;
-    }
+  }
 
   // Check if this item is in an implicit link directory.
   std::string dir = cmSystemTools::GetFilenamePath(item);
-  if(this->ImplicitLinkDirs.find(dir) == this->ImplicitLinkDirs.end())
-    {
+  if (this->ImplicitLinkDirs.find(dir) == this->ImplicitLinkDirs.end()) {
     // Only libraries in implicit link directories are converted to
     // pathless items.
     return false;
-    }
+  }
 
   // Only apply the policy below if the library file is one that can
   // be found by the linker.
   std::string file = cmSystemTools::GetFilenameName(item);
-  if(!this->ExtractAnyLibraryName.find(file))
-    {
+  if (!this->ExtractAnyLibraryName.find(file)) {
     return false;
-    }
+  }
 
   // Check the policy for whether we should use the approach below.
-  switch (this->Target->GetPolicyStatusCMP0060())
-    {
+  switch (this->Target->GetPolicyStatusCMP0060()) {
     case cmPolicies::WARN:
-      if (this->CMP0060Warn)
-        {
+      if (this->CMP0060Warn) {
         // Print the warning at most once for this item.
         std::string const& wid = "CMP0060-WARNING-GIVEN-" + item;
-        if (!this->CMakeInstance->GetPropertyAsBool(wid))
-          {
+        if (!this->CMakeInstance->GetPropertyAsBool(wid)) {
           this->CMakeInstance->SetProperty(wid, "1");
           this->CMP0060WarnItems.insert(item);
-          }
         }
+      }
     case cmPolicies::OLD:
       break;
     case cmPolicies::REQUIRED_ALWAYS:
     case cmPolicies::REQUIRED_IF_USED:
     case cmPolicies::NEW:
       return false;
-    }
+  }
 
   // Many system linkers support multiple architectures by
   // automatically selecting the implicit linker search path for the
@@ -1247,17 +1129,15 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
   //   libfoo.a  ==>  -Wl,-Bstatic -lfoo
 
   // Pass flags through untouched.
-  if(item[0] == '-' || item[0] == '$' || item[0] == '`')
-    {
+  if (item[0] == '-' || item[0] == '$' || item[0] == '`') {
     // if this is a -l option then we might need to warn about
     // CMP0003 so put it in OldUserFlagItems, if it is not a -l
     // or -Wl,-l (-framework -pthread), then allow it without a
     // CMP0003 as -L will not affect those other linker flags
-    if(item.find("-l") == 0 ||  item.find("-Wl,-l") == 0)
-      {
+    if (item.find("-l") == 0 || item.find("-Wl,-l") == 0) {
       // This is a linker option provided by the user.
       this->OldUserFlagItems.push_back(item);
-      }
+    }
 
     // Restore the target link type since this item does not specify
     // one.
@@ -1266,7 +1146,7 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
     // Use the item verbatim.
     this->Items.push_back(Item(item, false));
     return;
-    }
+  }
 
   // Parse out the prefix, base, and suffix components of the
   // library name.  If the name matches that of a shared or static
@@ -1279,9 +1159,8 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
   // libraries.  On AIX a library with the name libfoo.a can be
   // shared!
   std::string lib;
-  if(this->ExtractSharedLibraryName.find(item))
-    {
-    // This matches a shared library file name.
+  if (this->ExtractSharedLibraryName.find(item)) {
+// This matches a shared library file name.
 #ifdef CM_COMPUTE_LINK_INFO_DEBUG
     fprintf(stderr, "shared regex matched [%s] [%s] [%s]\n",
             this->ExtractSharedLibraryName.match(1).c_str(),
@@ -1293,10 +1172,8 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
 
     // Use just the library name so the linker will search.
     lib = this->ExtractSharedLibraryName.match(2);
-    }
-  else if(this->ExtractStaticLibraryName.find(item))
-    {
-    // This matches a static library file name.
+  } else if (this->ExtractStaticLibraryName.find(item)) {
+// This matches a static library file name.
 #ifdef CM_COMPUTE_LINK_INFO_DEBUG
     fprintf(stderr, "static regex matched [%s] [%s] [%s]\n",
             this->ExtractStaticLibraryName.match(1).c_str(),
@@ -1308,10 +1185,8 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
 
     // Use just the library name so the linker will search.
     lib = this->ExtractStaticLibraryName.match(2);
-    }
-  else if(this->ExtractAnyLibraryName.find(item))
-    {
-    // This matches a library file name.
+  } else if (this->ExtractAnyLibraryName.find(item)) {
+// This matches a library file name.
 #ifdef CM_COMPUTE_LINK_INFO_DEBUG
     fprintf(stderr, "any regex matched [%s] [%s] [%s]\n",
             this->ExtractAnyLibraryName.match(1).c_str(),
@@ -1324,21 +1199,18 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
 
     // Use just the library name so the linker will search.
     lib = this->ExtractAnyLibraryName.match(2);
-    }
-  else
-    {
+  } else {
     // This is a name specified by the user.
-    if(pathNotKnown)
-      {
+    if (pathNotKnown) {
       this->OldUserFlagItems.push_back(item);
-      }
+    }
 
     // We must ask the linker to search for a library with this name.
     // Restore the target link type since this item does not specify
     // one.
     this->SetCurrentLinkType(this->StartLinkType);
     lib = item;
-    }
+  }
 
   // Create an option to ask the linker to search for the library.
   std::string out = this->LibLinkFlag;
@@ -1355,14 +1227,13 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
 void cmComputeLinkInformation::AddFrameworkItem(std::string const& item)
 {
   // Try to separate the framework name and path.
-  if(!this->SplitFramework.find(item.c_str()))
-    {
+  if (!this->SplitFramework.find(item.c_str())) {
     std::ostringstream e;
     e << "Could not parse framework path \"" << item << "\" "
       << "linked by target " << this->Target->GetName() << ".";
     cmSystemTools::Error(e.str().c_str());
     return;
-    }
+  }
 
   std::string fw_path = this->SplitFramework.match(1);
   std::string fw = this->SplitFramework.match(2);
@@ -1388,15 +1259,12 @@ void cmComputeLinkInformation::AddFrameworkItem(std::string const& item)
 
 void cmComputeLinkInformation::AddDirectoryItem(std::string const& item)
 {
-  if(this->Makefile->IsOn("APPLE")
-     && cmSystemTools::IsPathToFramework(item.c_str()))
-    {
+  if (this->Makefile->IsOn("APPLE") &&
+      cmSystemTools::IsPathToFramework(item.c_str())) {
     this->AddFrameworkItem(item);
-    }
-  else
-    {
+  } else {
     this->DropDirectoryItem(item);
-    }
+  }
 }
 
 void cmComputeLinkInformation::DropDirectoryItem(std::string const& item)
@@ -1417,21 +1285,19 @@ void cmComputeLinkInformation::ComputeFrameworkInfo()
   std::vector<std::string> implicitDirVec;
 
   // Get platform-wide implicit directories.
-  if(const char* implicitLinks = this->Makefile->GetDefinition
-     ("CMAKE_PLATFORM_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES"))
-    {
+  if (const char* implicitLinks = this->Makefile->GetDefinition(
+        "CMAKE_PLATFORM_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES")) {
     cmSystemTools::ExpandListArgument(implicitLinks, implicitDirVec);
-    }
+  }
 
   // Get language-specific implicit directories.
   std::string implicitDirVar = "CMAKE_";
   implicitDirVar += this->LinkLanguage;
   implicitDirVar += "_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES";
-  if(const char* implicitDirs =
-     this->Makefile->GetDefinition(implicitDirVar))
-    {
+  if (const char* implicitDirs =
+        this->Makefile->GetDefinition(implicitDirVar)) {
     cmSystemTools::ExpandListArgument(implicitDirs, implicitDirVec);
-    }
+  }
 
   this->FrameworkPathsEmmitted.insert(implicitDirVec.begin(),
                                       implicitDirVec.end());
@@ -1442,10 +1308,9 @@ void cmComputeLinkInformation::ComputeFrameworkInfo()
 
 void cmComputeLinkInformation::AddFrameworkPath(std::string const& p)
 {
-  if(this->FrameworkPathsEmmitted.insert(p).second)
-    {
+  if (this->FrameworkPathsEmmitted.insert(p).second) {
     this->FrameworkPaths.push_back(p);
-    }
+  }
 }
 
 bool cmComputeLinkInformation::CheckSharedLibNoSOName(std::string const& item)
@@ -1454,18 +1319,16 @@ bool cmComputeLinkInformation::CheckSharedLibNoSOName(std::string const& item)
   // library is given via path and was not built with an soname.  If
   // this is a shared library that might be the case.
   std::string file = cmSystemTools::GetFilenameName(item);
-  if(this->ExtractSharedLibraryName.find(file))
-    {
+  if (this->ExtractSharedLibraryName.find(file)) {
     // If we can guess the soname fairly reliably then assume the
     // library has one.  Otherwise assume the library has no builtin
     // soname.
     std::string soname;
-    if(!cmSystemTools::GuessLibrarySOName(item, soname))
-      {
+    if (!cmSystemTools::GuessLibrarySOName(item, soname)) {
       this->AddSharedLibNoSOName(item);
       return true;
-      }
     }
+  }
   return false;
 }
 
@@ -1489,10 +1352,9 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
   // Do not depend on things that do not exist.
   std::vector<std::string>::iterator i =
     std::find(this->Depends.begin(), this->Depends.end(), item);
-  if(i != this->Depends.end())
-    {
+  if (i != this->Depends.end()) {
     this->Depends.erase(i);
-    }
+  }
 
   // Tell the linker to search for the item and provide the proper
   // path for it.  Do not contribute to any CMP0003 warning (do not
@@ -1501,16 +1363,12 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
   this->OrderLinkerSearchPath->AddLinkLibrary(item);
 
   // Produce any needed message.
-  switch(this->Target->GetPolicyStatusCMP0008())
-    {
-    case cmPolicies::WARN:
-      {
+  switch (this->Target->GetPolicyStatusCMP0008()) {
+    case cmPolicies::WARN: {
       // Print the warning at most once for this item.
       std::string wid = "CMP0008-WARNING-GIVEN-";
       wid += item;
-      if(!this->CMakeInstance->GetState()
-              ->GetGlobalPropertyAsBool(wid))
-        {
+      if (!this->CMakeInstance->GetState()->GetGlobalPropertyAsBool(wid)) {
         this->CMakeInstance->GetState()->SetGlobalProperty(wid, "1");
         std::ostringstream w;
         /* clang-format off */
@@ -1520,9 +1378,9 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
           << "which is a full-path but not a valid library file name.";
         /* clang-format on */
         this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
-                                        this->Target->GetBacktrace());
-        }
+                                          this->Target->GetBacktrace());
       }
+    }
     case cmPolicies::OLD:
       // OLD behavior does not warn.
       break;
@@ -1530,8 +1388,7 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
       // NEW behavior will not get here.
       break;
     case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
-      {
+    case cmPolicies::REQUIRED_ALWAYS: {
       std::ostringstream e;
       /* clang-format off */
       e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0008) << "\n"
@@ -1541,34 +1398,30 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
       /* clang-format on */
       this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(),
                                         this->Target->GetBacktrace());
-      }
-      break;
-    }
+    } break;
+  }
 }
 
 bool cmComputeLinkInformation::FinishLinkerSearchDirectories()
 {
   // Support broken projects if necessary.
-  if(this->OldLinkDirItems.empty() || this->OldUserFlagItems.empty() ||
-     !this->OldLinkDirMode)
-    {
+  if (this->OldLinkDirItems.empty() || this->OldUserFlagItems.empty() ||
+      !this->OldLinkDirMode) {
     return true;
-    }
+  }
 
   // Enforce policy constraints.
-  switch(this->Target->GetPolicyStatusCMP0003())
-    {
+  switch (this->Target->GetPolicyStatusCMP0003()) {
     case cmPolicies::WARN:
-      if(!this->CMakeInstance->GetState()
-              ->GetGlobalPropertyAsBool("CMP0003-WARNING-GIVEN"))
-        {
-        this->CMakeInstance->GetState()
-            ->SetGlobalProperty("CMP0003-WARNING-GIVEN", "1");
+      if (!this->CMakeInstance->GetState()->GetGlobalPropertyAsBool(
+            "CMP0003-WARNING-GIVEN")) {
+        this->CMakeInstance->GetState()->SetGlobalProperty(
+          "CMP0003-WARNING-GIVEN", "1");
         std::ostringstream w;
         this->PrintLinkPolicyDiagnosis(w);
         this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
-                                        this->Target->GetBacktrace());
-        }
+                                          this->Target->GetBacktrace());
+      }
     case cmPolicies::OLD:
       // OLD behavior is to add the paths containing libraries with
       // known full paths as link directories.
@@ -1577,24 +1430,22 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories()
       // Should never happen due to assignment of OldLinkDirMode
       return true;
     case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
-      {
+    case cmPolicies::REQUIRED_ALWAYS: {
       std::ostringstream e;
       e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0003) << "\n";
       this->PrintLinkPolicyDiagnosis(e);
       this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(),
                                         this->Target->GetBacktrace());
       return false;
-      }
     }
+  }
 
   // Add the link directories for full path items.
-  for(std::vector<std::string>::const_iterator
-        i = this->OldLinkDirItems.begin();
-      i != this->OldLinkDirItems.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i =
+         this->OldLinkDirItems.begin();
+       i != this->OldLinkDirItems.end(); ++i) {
     this->OrderLinkerSearchPath->AddLinkLibrary(*i);
-    }
+  }
   return true;
 }
 
@@ -1612,52 +1463,47 @@ void cmComputeLinkInformation::PrintLinkPolicyDiagnosis(std::ostream& os)
   /* clang-format on */
 
   // List the items that might need the old-style paths.
-  os << "This warning appears because target \""
-     << this->Target->GetName() << "\" "
+  os << "This warning appears because target \"" << this->Target->GetName()
+     << "\" "
      << "links to some libraries for which the linker must search:\n";
   {
-  // Format the list of unknown items to be as short as possible while
-  // still fitting in the allowed width (a true solution would be the
-  // bin packing problem if we were allowed to change the order).
-  std::string::size_type max_size = 76;
-  std::string line;
-  const char* sep = "  ";
-  for(std::vector<std::string>::const_iterator
-        i = this->OldUserFlagItems.begin();
-      i != this->OldUserFlagItems.end(); ++i)
-    {
-    // If the addition of another item will exceed the limit then
-    // output the current line and reset it.  Note that the separator
-    // is either " " or ", " which is always 2 characters.
-    if(!line.empty() && (line.size() + i->size() + 2) > max_size)
-      {
-      os << line << "\n";
-      sep = "  ";
-      line = "";
+    // Format the list of unknown items to be as short as possible while
+    // still fitting in the allowed width (a true solution would be the
+    // bin packing problem if we were allowed to change the order).
+    std::string::size_type max_size = 76;
+    std::string line;
+    const char* sep = "  ";
+    for (std::vector<std::string>::const_iterator i =
+           this->OldUserFlagItems.begin();
+         i != this->OldUserFlagItems.end(); ++i) {
+      // If the addition of another item will exceed the limit then
+      // output the current line and reset it.  Note that the separator
+      // is either " " or ", " which is always 2 characters.
+      if (!line.empty() && (line.size() + i->size() + 2) > max_size) {
+        os << line << "\n";
+        sep = "  ";
+        line = "";
       }
-    line += sep;
-    line += *i;
-    // Convert to the other separator.
-    sep = ", ";
+      line += sep;
+      line += *i;
+      // Convert to the other separator.
+      sep = ", ";
     }
-  if(!line.empty())
-    {
-    os << line << "\n";
+    if (!line.empty()) {
+      os << line << "\n";
     }
   }
 
   // List the paths old behavior is adding.
   os << "and other libraries with known full path:\n";
   std::set<std::string> emitted;
-  for(std::vector<std::string>::const_iterator
-        i = this->OldLinkDirItems.begin();
-      i != this->OldLinkDirItems.end(); ++i)
-    {
-    if(emitted.insert(cmSystemTools::GetFilenamePath(*i)).second)
-      {
+  for (std::vector<std::string>::const_iterator i =
+         this->OldLinkDirItems.begin();
+       i != this->OldLinkDirItems.end(); ++i) {
+    if (emitted.insert(cmSystemTools::GetFilenamePath(*i)).second) {
       os << "  " << *i << "\n";
-      }
     }
+  }
 
   // Explain.
   os << "CMake is adding directories in the second list to the linker "
@@ -1673,34 +1519,29 @@ void cmComputeLinkInformation::LoadImplicitLinkInfo()
   std::vector<std::string> implicitDirVec;
 
   // Get platform-wide implicit directories.
-  if(const char* implicitLinks =
-     (this->Makefile->GetDefinition
-      ("CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES")))
-    {
+  if (const char* implicitLinks = (this->Makefile->GetDefinition(
+        "CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES"))) {
     cmSystemTools::ExpandListArgument(implicitLinks, implicitDirVec);
-    }
+  }
 
   // Append library architecture to all implicit platform directories
   // and add them to the set
-  if(const char* libraryArch =
-     this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE"))
-    {
+  if (const char* libraryArch =
+        this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE")) {
     for (std::vector<std::string>::const_iterator i = implicitDirVec.begin();
-         i != implicitDirVec.end(); ++i)
-      {
+         i != implicitDirVec.end(); ++i) {
       this->ImplicitLinkDirs.insert(*i + "/" + libraryArch);
-      }
     }
+  }
 
   // Get language-specific implicit directories.
   std::string implicitDirVar = "CMAKE_";
   implicitDirVar += this->LinkLanguage;
   implicitDirVar += "_IMPLICIT_LINK_DIRECTORIES";
-  if(const char* implicitDirs =
-     this->Makefile->GetDefinition(implicitDirVar))
-    {
+  if (const char* implicitDirs =
+        this->Makefile->GetDefinition(implicitDirVar)) {
     cmSystemTools::ExpandListArgument(implicitDirs, implicitDirVec);
-    }
+  }
 
   // Store implicit link directories.
   this->ImplicitLinkDirs.insert(implicitDirVec.begin(), implicitDirVec.end());
@@ -1710,32 +1551,27 @@ void cmComputeLinkInformation::LoadImplicitLinkInfo()
   std::string implicitLibVar = "CMAKE_";
   implicitLibVar += this->LinkLanguage;
   implicitLibVar += "_IMPLICIT_LINK_LIBRARIES";
-  if(const char* implicitLibs =
-     this->Makefile->GetDefinition(implicitLibVar))
-    {
+  if (const char* implicitLibs =
+        this->Makefile->GetDefinition(implicitLibVar)) {
     cmSystemTools::ExpandListArgument(implicitLibs, implicitLibVec);
-    }
+  }
 
   // Store implicit link libraries.
-  for(std::vector<std::string>::const_iterator i = implicitLibVec.begin();
-      i != implicitLibVec.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = implicitLibVec.begin();
+       i != implicitLibVec.end(); ++i) {
     // Items starting in '-' but not '-l' are flags, not libraries,
     // and should not be filtered by this implicit list.
     std::string const& item = *i;
-    if(item[0] != '-' || item[1] == 'l')
-      {
+    if (item[0] != '-' || item[1] == 'l') {
       this->ImplicitLinkLibs.insert(item);
-      }
     }
+  }
 
   // Get platform specific rpath link directories
-  if(const char *rpathDirs =
-     (this->Makefile->GetDefinition
-      ("CMAKE_PLATFORM_RUNTIME_PATH")))
-    {
+  if (const char* rpathDirs =
+        (this->Makefile->GetDefinition("CMAKE_PLATFORM_RUNTIME_PATH"))) {
     cmSystemTools::ExpandListArgument(rpathDirs, this->RuntimeLinkDirs);
-    }
+  }
 }
 
 std::vector<std::string> const&
@@ -1744,113 +1580,96 @@ cmComputeLinkInformation::GetRuntimeSearchPath()
   return this->OrderRuntimeSearchPath->GetOrderedDirectories();
 }
 
-void
-cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath,
-                                              cmGeneratorTarget const* target)
+void cmComputeLinkInformation::AddLibraryRuntimeInfo(
+  std::string const& fullPath, cmGeneratorTarget const* target)
 {
   // Ignore targets on Apple where install_name is not @rpath.
   // The dependenty library can be found with other means such as
   // @loader_path or full paths.
-  if(this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
-    {
-    if(!target->HasMacOSXRpathInstallNameDir(this->Config))
-      {
+  if (this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
+    if (!target->HasMacOSXRpathInstallNameDir(this->Config)) {
       return;
-      }
     }
+  }
 
   // Libraries with unknown type must be handled using just the file
   // on disk.
-  if(target->GetType() == cmState::UNKNOWN_LIBRARY)
-    {
+  if (target->GetType() == cmState::UNKNOWN_LIBRARY) {
     this->AddLibraryRuntimeInfo(fullPath);
     return;
-    }
+  }
 
   // Skip targets that are not shared libraries (modules cannot be linked).
-  if(target->GetType() != cmState::SHARED_LIBRARY)
-    {
+  if (target->GetType() != cmState::SHARED_LIBRARY) {
     return;
-    }
+  }
 
   // Try to get the soname of the library.  Only files with this name
   // could possibly conflict.
   std::string soName = target->GetSOName(this->Config);
-  const char* soname = soName.empty()? 0 : soName.c_str();
+  const char* soname = soName.empty() ? 0 : soName.c_str();
 
   // Include this library in the runtime path ordering.
   this->OrderRuntimeSearchPath->AddRuntimeLibrary(fullPath, soname);
-  if(this->LinkWithRuntimePath)
-    {
+  if (this->LinkWithRuntimePath) {
     this->OrderLinkerSearchPath->AddRuntimeLibrary(fullPath, soname);
-    }
+  }
 }
 
-void
-cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath)
+void cmComputeLinkInformation::AddLibraryRuntimeInfo(
+  std::string const& fullPath)
 {
   // Get the name of the library from the file name.
   bool is_shared_library = false;
   std::string file = cmSystemTools::GetFilenameName(fullPath);
 
-  if(this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
-    {
+  if (this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
     // Check that @rpath is part of the install name.
     // If it isn't, return.
     std::string soname;
-    if(!cmSystemTools::GuessLibraryInstallName(fullPath, soname))
-      {
+    if (!cmSystemTools::GuessLibraryInstallName(fullPath, soname)) {
       return;
-      }
+    }
 
-    if(soname.find("@rpath") == std::string::npos)
-      {
+    if (soname.find("@rpath") == std::string::npos) {
       return;
-      }
     }
+  }
 
   is_shared_library = this->ExtractSharedLibraryName.find(file);
 
-  if(!is_shared_library)
-    {
+  if (!is_shared_library) {
     // On some platforms (AIX) a shared library may look static.
-    if(this->ArchivesMayBeShared)
-      {
-      if(this->ExtractStaticLibraryName.find(file.c_str()))
-        {
+    if (this->ArchivesMayBeShared) {
+      if (this->ExtractStaticLibraryName.find(file.c_str())) {
         // This is the name of a shared library or archive.
         is_shared_library = true;
-        }
       }
     }
+  }
 
   // It could be an Apple framework
-  if(!is_shared_library)
-    {
-    if(fullPath.find(".framework") != std::string::npos)
-      {
-      static cmsys::RegularExpression
-        splitFramework("^(.*)/(.*).framework/(.*)$");
-      if(splitFramework.find(fullPath) &&
-        (std::string::npos !=
-         splitFramework.match(3).find(splitFramework.match(2))))
-        {
+  if (!is_shared_library) {
+    if (fullPath.find(".framework") != std::string::npos) {
+      static cmsys::RegularExpression splitFramework(
+        "^(.*)/(.*).framework/(.*)$");
+      if (splitFramework.find(fullPath) &&
+          (std::string::npos !=
+           splitFramework.match(3).find(splitFramework.match(2)))) {
         is_shared_library = true;
-        }
       }
     }
+  }
 
-  if(!is_shared_library)
-    {
+  if (!is_shared_library) {
     return;
-    }
+  }
 
   // Include this library in the runtime path ordering.
   this->OrderRuntimeSearchPath->AddRuntimeLibrary(fullPath);
-  if(this->LinkWithRuntimePath)
-    {
+  if (this->LinkWithRuntimePath) {
     this->OrderLinkerSearchPath->AddRuntimeLibrary(fullPath);
-    }
+  }
 }
 
 static void cmCLI_ExpandListUnique(const char* str,
@@ -1859,13 +1678,12 @@ static void cmCLI_ExpandListUnique(const char* str,
 {
   std::vector<std::string> tmp;
   cmSystemTools::ExpandListArgument(str, tmp);
-  for(std::vector<std::string>::iterator i = tmp.begin(); i != tmp.end(); ++i)
-    {
-    if(emitted.insert(*i).second)
-      {
+  for (std::vector<std::string>::iterator i = tmp.begin(); i != tmp.end();
+       ++i) {
+    if (emitted.insert(*i).second) {
       out.push_back(*i);
-      }
     }
+  }
 }
 
 void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
@@ -1886,103 +1704,82 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
   bool use_build_rpath =
     (outputRuntime && this->Target->HaveBuildTreeRPATH(this->Config) &&
      !linking_for_install);
-  bool use_link_rpath =
-    outputRuntime && linking_for_install &&
+  bool use_link_rpath = outputRuntime && linking_for_install &&
     !this->Makefile->IsOn("CMAKE_SKIP_INSTALL_RPATH") &&
     this->Target->GetPropertyAsBool("INSTALL_RPATH_USE_LINK_PATH");
 
   // Construct the RPATH.
   std::set<std::string> emitted;
-  if(use_install_rpath)
-    {
-    const char* install_rpath =
-        this->Target->GetProperty("INSTALL_RPATH");
+  if (use_install_rpath) {
+    const char* install_rpath = this->Target->GetProperty("INSTALL_RPATH");
     cmCLI_ExpandListUnique(install_rpath, runtimeDirs, emitted);
-    }
-  if(use_build_rpath || use_link_rpath)
-    {
+  }
+  if (use_build_rpath || use_link_rpath) {
     std::string rootPath = this->Makefile->GetSafeDefinition("CMAKE_SYSROOT");
-    const char *stagePath
-                  = this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX");
-    const char *installPrefix
-                  = this->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
+    const char* stagePath =
+      this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX");
+    const char* installPrefix =
+      this->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
     cmSystemTools::ConvertToUnixSlashes(rootPath);
     std::vector<std::string> const& rdirs = this->GetRuntimeSearchPath();
-    for(std::vector<std::string>::const_iterator ri = rdirs.begin();
-        ri != rdirs.end(); ++ri)
-      {
+    for (std::vector<std::string>::const_iterator ri = rdirs.begin();
+         ri != rdirs.end(); ++ri) {
       // Put this directory in the rpath if using build-tree rpath
       // support or if using the link path as an rpath.
-      if(use_build_rpath)
-        {
+      if (use_build_rpath) {
         std::string d = *ri;
-        if (!rootPath.empty() && d.find(rootPath) == 0)
-          {
+        if (!rootPath.empty() && d.find(rootPath) == 0) {
           d = d.substr(rootPath.size());
-          }
-        else if (stagePath && *stagePath && d.find(stagePath) == 0)
-          {
+        } else if (stagePath && *stagePath && d.find(stagePath) == 0) {
           std::string suffix = d.substr(strlen(stagePath));
           d = installPrefix;
           d += "/";
           d += suffix;
           cmSystemTools::ConvertToUnixSlashes(d);
-          }
-        if(emitted.insert(d).second)
-          {
+        }
+        if (emitted.insert(d).second) {
           runtimeDirs.push_back(d);
-          }
         }
-      else if(use_link_rpath)
-        {
+      } else if (use_link_rpath) {
         // Do not add any path inside the source or build tree.
         const char* topSourceDir = this->CMakeInstance->GetHomeDirectory();
         const char* topBinaryDir =
-            this->CMakeInstance->GetHomeOutputDirectory();
-        if(!cmSystemTools::ComparePath(*ri, topSourceDir) &&
-           !cmSystemTools::ComparePath(*ri, topBinaryDir) &&
-           !cmSystemTools::IsSubDirectory(*ri, topSourceDir) &&
-           !cmSystemTools::IsSubDirectory(*ri, topBinaryDir))
-          {
+          this->CMakeInstance->GetHomeOutputDirectory();
+        if (!cmSystemTools::ComparePath(*ri, topSourceDir) &&
+            !cmSystemTools::ComparePath(*ri, topBinaryDir) &&
+            !cmSystemTools::IsSubDirectory(*ri, topSourceDir) &&
+            !cmSystemTools::IsSubDirectory(*ri, topBinaryDir)) {
           std::string d = *ri;
-          if (!rootPath.empty() && d.find(rootPath) == 0)
-            {
+          if (!rootPath.empty() && d.find(rootPath) == 0) {
             d = d.substr(rootPath.size());
-            }
-          else if (stagePath && *stagePath && d.find(stagePath) == 0)
-            {
+          } else if (stagePath && *stagePath && d.find(stagePath) == 0) {
             std::string suffix = d.substr(strlen(stagePath));
             d = installPrefix;
             d += "/";
             d += suffix;
             cmSystemTools::ConvertToUnixSlashes(d);
-            }
-          if(emitted.insert(d).second)
-            {
+          }
+          if (emitted.insert(d).second) {
             runtimeDirs.push_back(d);
-            }
           }
         }
       }
     }
+  }
 
   // Add runtime paths required by the languages to always be
   // present.  This is done even when skipping rpath support.
   {
-  cmGeneratorTarget::LinkClosure const* lc =
-    this->Target->GetLinkClosure(this->Config);
-  for(std::vector<std::string>::const_iterator li = lc->Languages.begin();
-      li != lc->Languages.end(); ++li)
-    {
-    std::string useVar = "CMAKE_" + *li +
-      "_USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH";
-    if(this->Makefile->IsOn(useVar))
-      {
-      std::string dirVar = "CMAKE_" + *li +
-        "_IMPLICIT_LINK_DIRECTORIES";
-      if(const char* dirs = this->Makefile->GetDefinition(dirVar))
-        {
-        cmCLI_ExpandListUnique(dirs, runtimeDirs, emitted);
+    cmGeneratorTarget::LinkClosure const* lc =
+      this->Target->GetLinkClosure(this->Config);
+    for (std::vector<std::string>::const_iterator li = lc->Languages.begin();
+         li != lc->Languages.end(); ++li) {
+      std::string useVar =
+        "CMAKE_" + *li + "_USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH";
+      if (this->Makefile->IsOn(useVar)) {
+        std::string dirVar = "CMAKE_" + *li + "_IMPLICIT_LINK_DIRECTORIES";
+        if (const char* dirs = this->Makefile->GetDefinition(dirVar)) {
+          cmCLI_ExpandListUnique(dirs, runtimeDirs, emitted);
         }
       }
     }
@@ -2003,33 +1800,29 @@ std::string cmComputeLinkInformation::GetRPathString(bool for_install)
   std::string rpath = cmJoin(runtimeDirs, this->GetRuntimeSep());
 
   // If the rpath will be replaced at install time, prepare space.
-  if(!for_install && this->RuntimeUseChrpath)
-    {
-    if(!rpath.empty())
-      {
+  if (!for_install && this->RuntimeUseChrpath) {
+    if (!rpath.empty()) {
       // Add one trailing separator so the linker does not re-use the
       // rpath .dynstr entry for a symbol name that happens to match
       // the end of the rpath string.
       rpath += this->GetRuntimeSep();
-      }
+    }
 
     // Make sure it is long enough to hold the replacement value.
     std::string::size_type minLength = this->GetChrpathString().length();
-    while(rpath.length() < minLength)
-      {
+    while (rpath.length() < minLength) {
       rpath += this->GetRuntimeSep();
-      }
     }
+  }
 
   return rpath;
 }
 
 std::string cmComputeLinkInformation::GetChrpathString()
 {
-  if(!this->RuntimeUseChrpath)
-    {
+  if (!this->RuntimeUseChrpath) {
     return "";
-    }
+  }
 
   return this->GetRPathString(true);
 }