Method OrderLinkEntries

Source/cmComputeLinkDepends.cxx:1470–1520

}

void cmComputeLinkDepends::OrderLinkEntries()
{
  // The component graph is guaranteed to be acyclic.  Start a DFS
  // from every entry to compute a topological order for the
  // components.
  Graph const& cgraph = this->CCG->GetComponentGraph();
  size_t n = cgraph.size();
  this->ComponentVisited.resize(cgraph.size(), 0);
  this->ComponentOrder.resize(cgraph.size(), n);
  this->ComponentOrderId = n;
  // Run in reverse order so the topological order will preserve the
  // original order where there are no constraints.
  for (size_t c = n; c > 0; --c) {
    this->VisitComponent(c - 1);
  }

  // Display the component graph.
  if (this->DebugMode) {
    this->DisplayComponents();
  }

  // Start with the original link line.
  switch (this->Strategy) {
    case LinkLibrariesStrategy::REORDER_MINIMALLY: {
      // Emit the direct dependencies in their original order.
      // This gives projects control over ordering.
      for (size_t originalEntry : this->OriginalEntries) {
        this->VisitEntry(originalEntry);
      }
    } break;
    case LinkLibrariesStrategy::REORDER_FREELY: {
      // Schedule the direct dependencies for emission in topo order.
      // This may produce more efficient link lines.
      for (size_t originalEntry : this->OriginalEntries) {
        this->MakePendingComponent(
          this->CCG->GetComponentMap()[originalEntry]);
      }
    } break;
  }

  // Now explore anything left pending.  Since the component graph is
  // guaranteed to be acyclic we know this will terminate.
  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.
    size_t e = *this->PendingComponents.begin()->second.Entries.begin();
    this->VisitEntry(e);
  }
}

void cmComputeLinkDepends::DisplayComponents()
{