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, 176 insertions, 279 deletions

diff --git a/Source/cmComputeLinkDepends.cxx b/Source/cmComputeLinkDepends.cxx
index 23ea371..2129394 100644
--- a/Source/cmComputeLinkDepends.cxx
+++ b/Source/cmComputeLinkDepends.cxx
@@ -170,20 +170,19 @@ items that we know the linker will re-use automatically (shared libs).
 
 */
 
-cmComputeLinkDepends
-::cmComputeLinkDepends(const cmGeneratorTarget* target,
-                       const std::string& config)
+cmComputeLinkDepends::cmComputeLinkDepends(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();
 
   // The configuration being linked.
   this->HasConfig = !config.empty();
-  this->Config = (this->HasConfig)? config : std::string();
+  this->Config = (this->HasConfig) ? config : std::string();
   std::vector<std::string> debugConfigs =
     this->Makefile->GetCMakeInstance()->GetDebugConfigs();
   this->LinkType = CMP0003_ComputeLinkType(this->Config, debugConfigs);
@@ -216,23 +215,21 @@ cmComputeLinkDepends::Compute()
   this->AddDirectLinkEntries();
 
   // Complete the breadth-first search of dependencies.
-  while(!this->BFSQueue.empty())
-    {
+  while (!this->BFSQueue.empty()) {
     // Get the next entry.
     BFSEntry qe = this->BFSQueue.front();
     this->BFSQueue.pop();
 
     // Follow the entry's dependencies.
     this->FollowLinkEntry(qe);
-    }
+  }
 
   // Complete the search of shared library dependencies.
-  while(!this->SharedDepQueue.empty())
-    {
+  while (!this->SharedDepQueue.empty()) {
     // Handle the next entry.
     this->HandleSharedDependency(this->SharedDepQueue.front());
     this->SharedDepQueue.pop();
-    }
+  }
 
   // Infer dependencies of targets for which they were not known.
   this->InferDependencies();
@@ -241,16 +238,14 @@ cmComputeLinkDepends::Compute()
   this->CleanConstraintGraph();
 
   // Display the constraint graph.
-  if(this->DebugMode)
-    {
-    fprintf(stderr,
-            "---------------------------------------"
-            "---------------------------------------\n");
+  if (this->DebugMode) {
+    fprintf(stderr, "---------------------------------------"
+                    "---------------------------------------\n");
     fprintf(stderr, "Link dependency analysis for target %s, config %s\n",
             this->Target->GetName().c_str(),
-            this->HasConfig?this->Config.c_str():"noconfig");
+            this->HasConfig ? this->Config.c_str() : "noconfig");
     this->DisplayConstraintGraph();
-    }
+  }
 
   // Compute the final ordering.
   this->OrderLinkEntires();
@@ -259,40 +254,37 @@ cmComputeLinkDepends::Compute()
   // Iterate in reverse order so we can keep only the last occurrence
   // of a shared library.
   std::set<int> emmitted;
-  for(std::vector<int>::const_reverse_iterator
-        li = this->FinalLinkOrder.rbegin(),
-        le = this->FinalLinkOrder.rend();
-      li != le; ++li)
-    {
+  for (std::vector<int>::const_reverse_iterator
+         li = this->FinalLinkOrder.rbegin(),
+         le = this->FinalLinkOrder.rend();
+       li != le; ++li) {
     int i = *li;
     LinkEntry const& e = this->EntryList[i];
     cmGeneratorTarget const* t = e.Target;
     // Entries that we know the linker will re-use do not need to be repeated.
     bool uniquify = t && t->GetType() == cmState::SHARED_LIBRARY;
-    if(!uniquify || emmitted.insert(i).second)
-      {
+    if (!uniquify || emmitted.insert(i).second) {
       this->FinalLinkEntries.push_back(e);
-      }
     }
+  }
   // Reverse the resulting order since we iterated in reverse.
   std::reverse(this->FinalLinkEntries.begin(), this->FinalLinkEntries.end());
 
   // Display the final set.
-  if(this->DebugMode)
-    {
+  if (this->DebugMode) {
     this->DisplayFinalEntries();
-    }
+  }
 
   return this->FinalLinkEntries;
 }
 
-std::map<std::string, int>::iterator
-cmComputeLinkDepends::AllocateLinkEntry(std::string const& item)
+std::map<std::string, int>::iterator cmComputeLinkDepends::AllocateLinkEntry(
+  std::string const& item)
 {
-  std::map<std::string, int>::value_type
-    index_entry(item, static_cast<int>(this->EntryList.size()));
-  std::map<std::string, int>::iterator
-    lei = this->LinkEntryIndex.insert(index_entry).first;
+  std::map<std::string, int>::value_type index_entry(
+    item, static_cast<int>(this->EntryList.size()));
+  std::map<std::string, int>::iterator lei =
+    this->LinkEntryIndex.insert(index_entry).first;
   this->EntryList.push_back(LinkEntry());
   this->InferredDependSets.push_back(0);
   this->EntryConstraintGraph.push_back(EdgeList());
@@ -303,11 +295,10 @@ int cmComputeLinkDepends::AddLinkEntry(cmLinkItem const& item)
 {
   // Check if the item entry has already been added.
   std::map<std::string, int>::iterator lei = this->LinkEntryIndex.find(item);
-  if(lei != this->LinkEntryIndex.end())
-    {
+  if (lei != this->LinkEntryIndex.end()) {
     // Yes.  We do not need to follow the item's dependencies again.
     return lei->second;
-    }
+  }
 
   // Allocate a spot for the item entry.
   lei = this->AllocateLinkEntry(item);
@@ -321,29 +312,23 @@ int cmComputeLinkDepends::AddLinkEntry(cmLinkItem const& item)
                   item.substr(0, 10) != "-framework");
 
   // If the item has dependencies queue it to follow them.
-  if(entry.Target)
-    {
+  if (entry.Target) {
     // Target dependencies are always known.  Follow them.
-    BFSEntry qe = {index, 0};
+    BFSEntry qe = { index, 0 };
     this->BFSQueue.push(qe);
-    }
-  else
-    {
+  } else {
     // Look for an old-style <item>_LIB_DEPENDS variable.
     std::string var = entry.Item;
     var += "_LIB_DEPENDS";
-    if(const char* val = this->Makefile->GetDefinition(var))
-      {
+    if (const char* val = this->Makefile->GetDefinition(var)) {
       // The item dependencies are known.  Follow them.
-      BFSEntry qe = {index, val};
+      BFSEntry qe = { index, val };
       this->BFSQueue.push(qe);
-      }
-    else if(!entry.IsFlag)
-      {
+    } else if (!entry.IsFlag) {
       // The item dependencies are not known.  We need to infer them.
       this->InferredDependSets[index] = new DependSetList;
-      }
     }
+  }
 
   return index;
 }
@@ -355,70 +340,58 @@ void cmComputeLinkDepends::FollowLinkEntry(BFSEntry const& qe)
   LinkEntry const& entry = this->EntryList[depender_index];
 
   // Follow the item's dependencies.
-  if(entry.Target)
-    {
+  if (entry.Target) {
     // Follow the target dependencies.
-    if(cmLinkInterface const* iface =
-       entry.Target->GetLinkInterface(this->Config, this->Target))
-      {
+    if (cmLinkInterface const* iface =
+          entry.Target->GetLinkInterface(this->Config, this->Target)) {
       const bool isIface =
-                      entry.Target->GetType() == cmState::INTERFACE_LIBRARY;
+        entry.Target->GetType() == cmState::INTERFACE_LIBRARY;
       // This target provides its own link interface information.
       this->AddLinkEntries(depender_index, iface->Libraries);
 
-      if (isIface)
-        {
+      if (isIface) {
         return;
-        }
+      }
 
       // Handle dependent shared libraries.
       this->FollowSharedDeps(depender_index, iface);
 
       // Support for CMP0003.
-      for(std::vector<cmLinkItem>::const_iterator
-            oi = iface->WrongConfigLibraries.begin();
-          oi != iface->WrongConfigLibraries.end(); ++oi)
-        {
+      for (std::vector<cmLinkItem>::const_iterator oi =
+             iface->WrongConfigLibraries.begin();
+           oi != iface->WrongConfigLibraries.end(); ++oi) {
         this->CheckWrongConfigItem(*oi);
-        }
       }
     }
-  else
-    {
+  } else {
     // Follow the old-style dependency list.
     this->AddVarLinkEntries(depender_index, qe.LibDepends);
-    }
+  }
 }
 
-void
-cmComputeLinkDepends
-::FollowSharedDeps(int depender_index, cmLinkInterface const* iface,
-                   bool follow_interface)
+void cmComputeLinkDepends::FollowSharedDeps(int depender_index,
+                                            cmLinkInterface const* iface,
+                                            bool follow_interface)
 {
   // Follow dependencies if we have not followed them already.
-  if(this->SharedDepFollowed.insert(depender_index).second)
-    {
-    if(follow_interface)
-      {
+  if (this->SharedDepFollowed.insert(depender_index).second) {
+    if (follow_interface) {
       this->QueueSharedDependencies(depender_index, iface->Libraries);
-      }
-    this->QueueSharedDependencies(depender_index, iface->SharedDeps);
     }
+    this->QueueSharedDependencies(depender_index, iface->SharedDeps);
+  }
 }
 
-void
-cmComputeLinkDepends
-::QueueSharedDependencies(int depender_index,
-                          std::vector<cmLinkItem> const& deps)
+void cmComputeLinkDepends::QueueSharedDependencies(
+  int depender_index, std::vector<cmLinkItem> const& deps)
 {
-  for(std::vector<cmLinkItem>::const_iterator li = deps.begin();
-      li != deps.end(); ++li)
-    {
+  for (std::vector<cmLinkItem>::const_iterator li = deps.begin();
+       li != deps.end(); ++li) {
     SharedDepEntry qe;
     qe.Item = *li;
     qe.DependerIndex = depender_index;
     this->SharedDepQueue.push(qe);
-    }
+  }
 }
 
 void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep)
@@ -426,8 +399,7 @@ void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep)
   // Check if the target already has an entry.
   std::map<std::string, int>::iterator lei =
     this->LinkEntryIndex.find(dep.Item);
-  if(lei == this->LinkEntryIndex.end())
-    {
+  if (lei == this->LinkEntryIndex.end()) {
     // Allocate a spot for the item entry.
     lei = this->AllocateLinkEntry(dep.Item);
 
@@ -440,7 +412,7 @@ void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep)
     // shared library.  It may get special treatment
     // in cmComputeLinkInformation.
     entry.IsSharedDep = true;
-    }
+  }
 
   // Get the link entry for this target.
   int index = lei->second;
@@ -451,15 +423,13 @@ void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep)
   this->EntryConstraintGraph[dep.DependerIndex].push_back(index);
 
   // Target items may have their own dependencies.
-  if(entry.Target)
-    {
-    if(cmLinkInterface const* iface =
-       entry.Target->GetLinkInterface(this->Config, this->Target))
-      {
+  if (entry.Target) {
+    if (cmLinkInterface const* iface =
+          entry.Target->GetLinkInterface(this->Config, this->Target)) {
       // Follow public and private dependencies transitively.
       this->FollowSharedDeps(index, iface, true);
-      }
     }
+  }
 }
 
 void cmComputeLinkDepends::AddVarLinkEntries(int depender_index,
@@ -475,65 +445,49 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index,
   std::vector<cmLinkItem> actual_libs;
   cmTargetLinkLibraryType llt = GENERAL_LibraryType;
   bool haveLLT = false;
-  for(std::vector<std::string>::const_iterator di = deplist.begin();
-      di != deplist.end(); ++di)
-    {
-    if(*di == "debug")
-      {
+  for (std::vector<std::string>::const_iterator di = deplist.begin();
+       di != deplist.end(); ++di) {
+    if (*di == "debug") {
       llt = DEBUG_LibraryType;
       haveLLT = true;
-      }
-    else if(*di == "optimized")
-      {
+    } else if (*di == "optimized") {
       llt = OPTIMIZED_LibraryType;
       haveLLT = true;
-      }
-    else if(*di == "general")
-      {
+    } else if (*di == "general") {
       llt = GENERAL_LibraryType;
       haveLLT = true;
-      }
-    else if(!di->empty())
-      {
+    } else if (!di->empty()) {
       // If no explicit link type was given prior to this entry then
       // check if the entry has its own link type variable.  This is
       // needed for compatibility with dependency files generated by
       // the export_library_dependencies command from CMake 2.4 and
       // lower.
-      if(!haveLLT)
-        {
+      if (!haveLLT) {
         std::string var = *di;
         var += "_LINK_TYPE";
-        if(const char* val = this->Makefile->GetDefinition(var))
-          {
-          if(strcmp(val, "debug") == 0)
-            {
+        if (const char* val = this->Makefile->GetDefinition(var)) {
+          if (strcmp(val, "debug") == 0) {
             llt = DEBUG_LibraryType;
-            }
-          else if(strcmp(val, "optimized") == 0)
-            {
+          } else if (strcmp(val, "optimized") == 0) {
             llt = OPTIMIZED_LibraryType;
-            }
           }
         }
+      }
 
       // If the library is meant for this link type then use it.
-      if(llt == GENERAL_LibraryType || llt == this->LinkType)
-        {
+      if (llt == GENERAL_LibraryType || llt == this->LinkType) {
         cmLinkItem item(*di, this->FindTargetToLink(depender_index, *di));
         actual_libs.push_back(item);
-        }
-      else if(this->OldLinkDirMode)
-        {
+      } else if (this->OldLinkDirMode) {
         cmLinkItem item(*di, this->FindTargetToLink(depender_index, *di));
         this->CheckWrongConfigItem(item);
-        }
+      }
 
       // Reset the link type until another explicit type is given.
       llt = GENERAL_LibraryType;
       haveLLT = false;
-      }
     }
+  }
 
   // Add the entries from this list.
   this->AddLinkEntries(depender_index, actual_libs);
@@ -545,94 +499,80 @@ void cmComputeLinkDepends::AddDirectLinkEntries()
   cmLinkImplementation const* impl =
     this->Target->GetLinkImplementation(this->Config);
   this->AddLinkEntries(-1, impl->Libraries);
-  for(std::vector<cmLinkItem>::const_iterator
-        wi = impl->WrongConfigLibraries.begin();
-      wi != impl->WrongConfigLibraries.end(); ++wi)
-    {
+  for (std::vector<cmLinkItem>::const_iterator wi =
+         impl->WrongConfigLibraries.begin();
+       wi != impl->WrongConfigLibraries.end(); ++wi) {
     this->CheckWrongConfigItem(*wi);
-    }
+  }
 }
 
 template <typename T>
-void
-cmComputeLinkDepends::AddLinkEntries(
-  int depender_index, std::vector<T> const& libs)
+void cmComputeLinkDepends::AddLinkEntries(int depender_index,
+                                          std::vector<T> const& libs)
 {
   // Track inferred dependency sets implied by this list.
   std::map<int, DependSet> dependSets;
 
   // Loop over the libraries linked directly by the depender.
-  for(typename std::vector<T>::const_iterator li = libs.begin();
-      li != libs.end(); ++li)
-    {
+  for (typename std::vector<T>::const_iterator li = libs.begin();
+       li != libs.end(); ++li) {
     // Skip entries that will resolve to the target getting linked or
     // are empty.
     cmLinkItem const& item = *li;
-    if(item == this->Target->GetName() || item.empty())
-      {
+    if (item == this->Target->GetName() || item.empty()) {
       continue;
-      }
+    }
 
     // Add a link entry for this item.
     int dependee_index = this->AddLinkEntry(*li);
 
     // The dependee must come after the depender.
-    if(depender_index >= 0)
-      {
+    if (depender_index >= 0) {
       this->EntryConstraintGraph[depender_index].push_back(dependee_index);
-      }
-    else
-      {
+    } else {
       // This is a direct dependency of the target being linked.
       this->OriginalEntries.push_back(dependee_index);
-      }
+    }
 
     // Update the inferred dependencies for earlier items.
-    for(std::map<int, DependSet>::iterator dsi = dependSets.begin();
-        dsi != dependSets.end(); ++dsi)
-      {
+    for (std::map<int, DependSet>::iterator dsi = dependSets.begin();
+         dsi != dependSets.end(); ++dsi) {
       // Add this item to the inferred dependencies of other items.
       // Target items are never inferred dependees because unknown
       // items are outside libraries that should not be depending on
       // targets.
-      if(!this->EntryList[dependee_index].Target &&
-         !this->EntryList[dependee_index].IsFlag &&
-         dependee_index != dsi->first)
-        {
+      if (!this->EntryList[dependee_index].Target &&
+          !this->EntryList[dependee_index].IsFlag &&
+          dependee_index != dsi->first) {
         dsi->second.insert(dependee_index);
-        }
       }
+    }
 
     // If this item needs to have dependencies inferred, do so.
-    if(this->InferredDependSets[dependee_index])
-      {
+    if (this->InferredDependSets[dependee_index]) {
       // Make sure an entry exists to hold the set for the item.
       dependSets[dependee_index];
-      }
     }
+  }
 
   // Store the inferred dependency sets discovered for this list.
-  for(std::map<int, DependSet>::iterator dsi = dependSets.begin();
-      dsi != dependSets.end(); ++dsi)
-    {
+  for (std::map<int, DependSet>::iterator dsi = dependSets.begin();
+       dsi != dependSets.end(); ++dsi) {
     this->InferredDependSets[dsi->first]->push_back(dsi->second);
-    }
+  }
 }
 
-cmGeneratorTarget const*
-cmComputeLinkDepends::FindTargetToLink(int depender_index,
-                                       const std::string& name)
+cmGeneratorTarget const* cmComputeLinkDepends::FindTargetToLink(
+  int depender_index, const std::string& name)
 {
   // Look for a target in the scope of the depender.
   cmGeneratorTarget const* from = this->Target;
-  if(depender_index >= 0)
-    {
-    if(cmGeneratorTarget const* depender =
-       this->EntryList[depender_index].Target)
-      {
+  if (depender_index >= 0) {
+    if (cmGeneratorTarget const* depender =
+          this->EntryList[depender_index].Target) {
       from = depender;
-      }
     }
+  }
   return from->FindTargetToLink(name);
 }
 
@@ -641,59 +581,53 @@ void cmComputeLinkDepends::InferDependencies()
   // The inferred dependency sets for each item list the possible
   // dependencies.  The intersection of the sets for one item form its
   // inferred dependencies.
-  for(unsigned int depender_index=0;
-      depender_index < this->InferredDependSets.size(); ++depender_index)
-    {
+  for (unsigned int depender_index = 0;
+       depender_index < this->InferredDependSets.size(); ++depender_index) {
     // Skip items for which dependencies do not need to be inferred or
     // for which the inferred dependency sets are empty.
     DependSetList* sets = this->InferredDependSets[depender_index];
-    if(!sets || sets->empty())
-      {
+    if (!sets || sets->empty()) {
       continue;
-      }
+    }
 
     // Intersect the sets for this item.
     DependSetList::const_iterator i = sets->begin();
     DependSet common = *i;
-    for(++i; i != sets->end(); ++i)
-      {
+    for (++i; i != sets->end(); ++i) {
       DependSet intersection;
-      std::set_intersection
-        (common.begin(), common.end(), i->begin(), i->end(),
-         std::inserter(intersection, intersection.begin()));
+      std::set_intersection(common.begin(), common.end(), i->begin(), i->end(),
+                            std::inserter(intersection, intersection.begin()));
       common = intersection;
-      }
+    }
 
     // Add the inferred dependencies to the graph.
     cmGraphEdgeList& edges = this->EntryConstraintGraph[depender_index];
     edges.insert(edges.end(), common.begin(), common.end());
-    }
+  }
 }
 
 void cmComputeLinkDepends::CleanConstraintGraph()
 {
-  for(Graph::iterator i = this->EntryConstraintGraph.begin();
-      i != this->EntryConstraintGraph.end(); ++i)
-    {
+  for (Graph::iterator i = this->EntryConstraintGraph.begin();
+       i != this->EntryConstraintGraph.end(); ++i) {
     // Sort the outgoing edges for each graph node so that the
     // original order will be preserved as much as possible.
     std::sort(i->begin(), i->end());
 
     // Make the edge list unique.
     i->erase(std::unique(i->begin(), i->end()), i->end());
-    }
+  }
 }
 
 void cmComputeLinkDepends::DisplayConstraintGraph()
 {
   // Display the graph nodes and their edges.
   std::ostringstream e;
-  for(unsigned int i=0; i < this->EntryConstraintGraph.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->EntryConstraintGraph.size(); ++i) {
     EdgeList const& nl = this->EntryConstraintGraph[i];
     e << "item " << i << " is [" << this->EntryList[i].Item << "]\n";
     e << cmWrap("  item ", nl, " must follow it", "\n") << "\n";
-    }
+  }
   fprintf(stderr, "%s\n", e.str().c_str());
 }
 
@@ -716,71 +650,60 @@ void cmComputeLinkDepends::OrderLinkEntires()
   this->ComponentOrderId = n;
   // Run in reverse order so the topological order will preserve the
   // original order where there are no constraints.
-  for(int c = n-1; c >= 0; --c)
-    {
+  for (int c = n - 1; c >= 0; --c) {
     this->VisitComponent(c);
-    }
+  }
 
   // Display the component graph.
-  if(this->DebugMode)
-    {
+  if (this->DebugMode) {
     this->DisplayComponents();
-    }
+  }
 
   // Start with the original link line.
-  for(std::vector<int>::const_iterator i = this->OriginalEntries.begin();
-      i != this->OriginalEntries.end(); ++i)
-    {
+  for (std::vector<int>::const_iterator i = this->OriginalEntries.begin();
+       i != this->OriginalEntries.end(); ++i) {
     this->VisitEntry(*i);
-    }
+  }
 
   // Now explore anything left pending.  Since the component graph is
   // guaranteed to be acyclic we know this will terminate.
-  while(!this->PendingComponents.empty())
-    {
+  while (!this->PendingComponents.empty()) {
     // Visit one entry from the first pending component.  The visit
     // logic will update the pending components accordingly.  Since
     // the pending components are kept in topological order this will
     // not repeat one.
     int e = *this->PendingComponents.begin()->second.Entries.begin();
     this->VisitEntry(e);
-    }
+  }
 }
 
-void
-cmComputeLinkDepends::DisplayComponents()
+void cmComputeLinkDepends::DisplayComponents()
 {
   fprintf(stderr, "The strongly connected components are:\n");
   std::vector<NodeList> const& components = this->CCG->GetComponents();
-  for(unsigned int c=0; c < components.size(); ++c)
-    {
+  for (unsigned int c = 0; c < components.size(); ++c) {
     fprintf(stderr, "Component (%u):\n", c);
     NodeList const& nl = components[c];
-    for(NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni)
-      {
+    for (NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
       int i = *ni;
-      fprintf(stderr, "  item %d [%s]\n", i,
-              this->EntryList[i].Item.c_str());
-      }
+      fprintf(stderr, "  item %d [%s]\n", i, this->EntryList[i].Item.c_str());
+    }
     EdgeList const& ol = this->CCG->GetComponentGraphEdges(c);
-    for(EdgeList::const_iterator oi = ol.begin(); oi != ol.end(); ++oi)
-      {
+    for (EdgeList::const_iterator oi = ol.begin(); oi != ol.end(); ++oi) {
       int i = *oi;
       fprintf(stderr, "  followed by Component (%d)\n", i);
-      }
-    fprintf(stderr, "  topo order index %d\n",
-            this->ComponentOrder[c]);
     }
+    fprintf(stderr, "  topo order index %d\n", this->ComponentOrder[c]);
+  }
   fprintf(stderr, "\n");
 }
 
 void cmComputeLinkDepends::VisitComponent(unsigned int c)
 {
   // Check if the node has already been visited.
-  if(this->ComponentVisited[c])
-    {
+  if (this->ComponentVisited[c]) {
     return;
-    }
+  }
 
   // We are now visiting this component so mark it.
   this->ComponentVisited[c] = 1;
@@ -789,11 +712,10 @@ void cmComputeLinkDepends::VisitComponent(unsigned int c)
   // Run in reverse order so the topological order will preserve the
   // original order where there are no constraints.
   EdgeList const& nl = this->CCG->GetComponentGraphEdges(c);
-  for(EdgeList::const_reverse_iterator ni = nl.rbegin();
-      ni != nl.rend(); ++ni)
-    {
+  for (EdgeList::const_reverse_iterator ni = nl.rbegin(); ni != nl.rend();
+       ++ni) {
     this->VisitComponent(*ni);
-    }
+  }
 
   // Assign an ordering id to this component.
   this->ComponentOrder[c] = --this->ComponentOrderId;
@@ -809,64 +731,52 @@ void cmComputeLinkDepends::VisitEntry(int index)
   int component = this->CCG->GetComponentMap()[index];
   std::map<int, PendingComponent>::iterator mi =
     this->PendingComponents.find(this->ComponentOrder[component]);
-  if(mi != this->PendingComponents.end())
-    {
+  if (mi != this->PendingComponents.end()) {
     // The entry is in an already pending component.
     PendingComponent& pc = mi->second;
 
     // Remove the entry from those pending in its component.
     pc.Entries.erase(index);
-    if(pc.Entries.empty())
-      {
+    if (pc.Entries.empty()) {
       // The complete component has been seen since it was last needed.
       --pc.Count;
 
-      if(pc.Count == 0)
-        {
+      if (pc.Count == 0) {
         // The component has been completed.
         this->PendingComponents.erase(mi);
         completed = true;
-        }
-      else
-        {
+      } else {
         // The whole component needs to be seen again.
         NodeList const& nl = this->CCG->GetComponent(component);
         assert(nl.size() > 1);
         pc.Entries.insert(nl.begin(), nl.end());
-        }
       }
     }
-  else
-    {
+  } else {
     // The entry is not in an already pending component.
     NodeList const& nl = this->CCG->GetComponent(component);
-    if(nl.size() > 1)
-      {
+    if (nl.size() > 1) {
       // This is a non-trivial component.  It is now pending.
       PendingComponent& pc = this->MakePendingComponent(component);
 
       // The starting entry has already been seen.
       pc.Entries.erase(index);
-      }
-    else
-      {
+    } else {
       // This is a trivial component, so it is already complete.
       completed = true;
-      }
     }
+  }
 
   // If the entry completed a component, the component's dependencies
   // are now pending.
-  if(completed)
-    {
+  if (completed) {
     EdgeList const& ol = this->CCG->GetComponentGraphEdges(component);
-    for(EdgeList::const_iterator oi = ol.begin(); oi != ol.end(); ++oi)
-      {
+    for (EdgeList::const_iterator oi = ol.begin(); oi != ol.end(); ++oi) {
       // This entire component is now pending no matter whether it has
       // been partially seen already.
       this->MakePendingComponent(*oi);
-      }
     }
+  }
 }
 
 cmComputeLinkDepends::PendingComponent&
@@ -878,13 +788,10 @@ cmComputeLinkDepends::MakePendingComponent(unsigned int component)
   pc.Id = component;
   NodeList const& nl = this->CCG->GetComponent(component);
 
-  if(nl.size() == 1)
-    {
+  if (nl.size() == 1) {
     // Trivial components need be seen only once.
     pc.Count = 1;
-    }
-  else
-    {
+  } else {
     // This is a non-trivial strongly connected component of the
     // original graph.  It consists of two or more libraries
     // (archives) that mutually require objects from one another.  In
@@ -898,7 +805,7 @@ cmComputeLinkDepends::MakePendingComponent(unsigned int component)
     // this component will come first which minimizes the number of
     // repeats needed.
     pc.Count = this->ComputeComponentCount(nl);
-    }
+  }
 
   // Store the entries to be seen.
   pc.Entries.insert(nl.begin(), nl.end());
@@ -909,54 +816,44 @@ cmComputeLinkDepends::MakePendingComponent(unsigned int component)
 int cmComputeLinkDepends::ComputeComponentCount(NodeList const& nl)
 {
   unsigned int count = 2;
-  for(NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni)
-    {
-    if(cmGeneratorTarget const* target = this->EntryList[*ni].Target)
-      {
-      if(cmLinkInterface const* iface =
-         target->GetLinkInterface(this->Config, this->Target))
-        {
-        if(iface->Multiplicity > count)
-          {
+  for (NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
+    if (cmGeneratorTarget const* target = this->EntryList[*ni].Target) {
+      if (cmLinkInterface const* iface =
+            target->GetLinkInterface(this->Config, this->Target)) {
+        if (iface->Multiplicity > count) {
           count = iface->Multiplicity;
-          }
         }
       }
     }
+  }
   return count;
 }
 
 void cmComputeLinkDepends::DisplayFinalEntries()
 {
   fprintf(stderr, "target [%s] links to:\n", this->Target->GetName().c_str());
-  for(std::vector<LinkEntry>::const_iterator lei =
-        this->FinalLinkEntries.begin();
-      lei != this->FinalLinkEntries.end(); ++lei)
-    {
-    if(lei->Target)
-      {
+  for (std::vector<LinkEntry>::const_iterator lei =
+         this->FinalLinkEntries.begin();
+       lei != this->FinalLinkEntries.end(); ++lei) {
+    if (lei->Target) {
       fprintf(stderr, "  target [%s]\n", lei->Target->GetName().c_str());
-      }
-    else
-      {
+    } else {
       fprintf(stderr, "  item [%s]\n", lei->Item.c_str());
-      }
     }
+  }
   fprintf(stderr, "\n");
 }
 
 void cmComputeLinkDepends::CheckWrongConfigItem(cmLinkItem const& item)
 {
-  if(!this->OldLinkDirMode)
-    {
+  if (!this->OldLinkDirMode) {
     return;
-    }
+  }
 
   // For CMake 2.4 bug-compatibility we need to consider the output
   // directories of targets linked in another configuration as link
   // directories.
-  if(item.Target && !item.Target->IsImported())
-    {
+  if (item.Target && !item.Target->IsImported()) {
     this->OldWrongConfigItems.insert(item.Target);
-    }
+  }
 }