hpin reorg code

network/HpinDrvrLoad.cc

@@ -21,73 +21,82 @@
 
 namespace sta {
 
-HpinDrvrLoad::HpinDrvrLoad(Pin *drvr,
+static void
-			   Pin *load,
+visitPinsAboveNet2(const Pin *hpin,
-			   PinSet *hpins_from_drvr,
+		   Net *above_net,
-			   PinSet *hpins_to_load) :
+		   NetSet &visited,
-  drvr_(drvr),
+		   HpinDrvrLoads &above_drvrs,
-  load_(load),
+		   HpinDrvrLoads &above_loads,
-  hpins_from_drvr_(hpins_from_drvr ? new PinSet(*hpins_from_drvr) : nullptr),
+		   PinSet *hpin_path,
-  hpins_to_load_(hpins_to_load ? new PinSet(*hpins_to_load) : nullptr)
+		   const Network *network);
-{
+static void
-}
+visitPinsBelowNet2(const Pin *hpin,
-
+		   Net *above_net,
-HpinDrvrLoad::HpinDrvrLoad(Pin *drvr,
+		   Net *below_net,
-			   Pin *load) :
+		   NetSet &visited,
-  drvr_(drvr),
+		   HpinDrvrLoads &below_drvrs,
-  load_(load)
+		   HpinDrvrLoads &below_loads,
-{
+		   PinSet *hpin_path,
-}
+		   const Network *network);
-
+static void
-HpinDrvrLoad::~HpinDrvrLoad()
+visitHpinDrvrLoads(HpinDrvrLoads drvrs,
-{
+		   HpinDrvrLoads loads,
-  delete hpins_from_drvr_;
+		   HpinDrvrLoadVisitor *visitor);
-  delete hpins_to_load_;
-}
 
 void
-HpinDrvrLoad::report(const Network *network)
+visitHpinDrvrLoads(const Pin *pin,
+		   const Network *network,
+		   HpinDrvrLoadVisitor *visitor)
 {
-  printf("%s -> %s: ", 
+  NetSet visited;
-	 drvr_ ? network->pathName(drvr_) : "-",
+  HpinDrvrLoads above_drvrs;
-	 load_ ? network->pathName(load_) : "-");
+  HpinDrvrLoads above_loads;
-  PinSet::Iterator pin_iter(hpins_from_drvr_);
+  PinSet hpin_path;
-  while (pin_iter.hasNext()) {
+  Net *above_net = network->net(pin);
-    Pin *pin = pin_iter.next();
+  if (above_net) {
-    printf("%s ", network->pathName(pin)); 
+    visitPinsAboveNet2(pin, above_net, visited, 
+		       above_drvrs, above_loads,
+		       &hpin_path, network);
   }
-  printf("* "); 
-  PinSet::Iterator pin_iter2(hpins_to_load_);
-  while (pin_iter2.hasNext()) {
-    Pin *pin = pin_iter2.next();
-    printf("%s ", network->pathName(pin)); 
- }
-  printf("\n");
-}
 
-void 
+  // Search down from hpin terminal.
-HpinDrvrLoad::setDrvr(Pin *drvr)
+  HpinDrvrLoads below_drvrs;
-{
+  HpinDrvrLoads below_loads;
-  drvr_ = drvr;
+  Term *term = network->term(pin);
-}
+  if (term) {
-
+    Net *below_net = network->net(term);
-bool
+    if (below_net)
-HpinDrvrLoadLess::operator()(const HpinDrvrLoad *drvr_load1,
+      visitPinsBelowNet2(pin, above_net, below_net, visited,
-			     const HpinDrvrLoad *drvr_load2) const
+			 below_drvrs, below_loads,
-{
+			 &hpin_path, network);
-  Pin *load1 = drvr_load1->load();
-  Pin *load2 = drvr_load2->load();
-  if (load1 == load2) {
-    Pin *drvr1 = drvr_load1->drvr();
-    Pin *drvr2 = drvr_load2->drvr();
-    return drvr1 < drvr2;
   }
-  else
+  if (network->isHierarchical(pin)) {
-    return load1 < load2;
+    visitHpinDrvrLoads(above_drvrs, below_loads, visitor);
+    visitHpinDrvrLoads(below_drvrs, above_loads, visitor);
+  }
+  else {
+    if (network->isDriver(pin)) {
+      HpinDrvrLoad drvr(const_cast<Pin*>(pin), nullptr, &hpin_path, nullptr);
+      HpinDrvrLoads drvrs;
+      drvrs.insert(&drvr);
+      visitHpinDrvrLoads(drvrs, below_loads, visitor);
+      visitHpinDrvrLoads(drvrs, above_loads, visitor);
+    }
+    // Bidirects are drivers and loads.
+    if (network->isLoad(pin)) {
+      HpinDrvrLoad load(nullptr, const_cast<Pin*>(pin), nullptr, &hpin_path);
+      HpinDrvrLoads loads;
+      loads.insert(&load);
+      visitHpinDrvrLoads(below_drvrs, loads, visitor);
+      visitHpinDrvrLoads(above_drvrs, loads, visitor);
+    }
+  }
+  above_drvrs.deleteContents();
+  above_loads.deleteContents();
+  below_drvrs.deleteContents();
+  below_loads.deleteContents();
 }
 
-////////////////////////////////////////////////////////////////
-
 static void
 visitPinsAboveNet2(const Pin *hpin,
 		   Net *above_net,
@@ -246,58 +255,71 @@ visitHpinDrvrLoads(HpinDrvrLoads drvrs,
   }
 }
 
-void
+////////////////////////////////////////////////////////////////
-visitHpinDrvrLoads(const Pin *pin,
-		   const Network *network,
-		   HpinDrvrLoadVisitor *visitor)
-{
-  NetSet visited;
-  HpinDrvrLoads above_drvrs;
-  HpinDrvrLoads above_loads;
-  PinSet hpin_path;
-  Net *above_net = network->net(pin);
-  if (above_net) {
-    visitPinsAboveNet2(pin, above_net, visited, 
-		       above_drvrs, above_loads,
-		       &hpin_path, network);
-  }
 
-  // Search down from hpin terminal.
+HpinDrvrLoad::HpinDrvrLoad(Pin *drvr,
-  HpinDrvrLoads below_drvrs;
+			   Pin *load,
-  HpinDrvrLoads below_loads;
+			   PinSet *hpins_from_drvr,
-  Term *term = network->term(pin);
+			   PinSet *hpins_to_load) :
-  if (term) {
+  drvr_(drvr),
-    Net *below_net = network->net(term);
+  load_(load),
-    if (below_net)
+  hpins_from_drvr_(hpins_from_drvr ? new PinSet(*hpins_from_drvr) : nullptr),
-      visitPinsBelowNet2(pin, above_net, below_net, visited,
+  hpins_to_load_(hpins_to_load ? new PinSet(*hpins_to_load) : nullptr)
-			 below_drvrs, below_loads,
+{
-			 &hpin_path, network);
+}
+
+HpinDrvrLoad::HpinDrvrLoad(Pin *drvr,
+			   Pin *load) :
+  drvr_(drvr),
+  load_(load)
+{
+}
+
+HpinDrvrLoad::~HpinDrvrLoad()
+{
+  delete hpins_from_drvr_;
+  delete hpins_to_load_;
+}
+
+void 
+HpinDrvrLoad::report(const Network *network)
+{
+  printf("%s -> %s: ", 
+	 drvr_ ? network->pathName(drvr_) : "-",
+	 load_ ? network->pathName(load_) : "-");
+  PinSet::Iterator pin_iter(hpins_from_drvr_);
+  while (pin_iter.hasNext()) {
+    Pin *pin = pin_iter.next();
+    printf("%s ", network->pathName(pin)); 
   }
-  if (network->isHierarchical(pin)) {
+  printf("* "); 
-    visitHpinDrvrLoads(above_drvrs, below_loads, visitor);
+  PinSet::Iterator pin_iter2(hpins_to_load_);
-    visitHpinDrvrLoads(below_drvrs, above_loads, visitor);
+  while (pin_iter2.hasNext()) {
+    Pin *pin = pin_iter2.next();
+    printf("%s ", network->pathName(pin)); 
+ }
+  printf("\n");
+}
+
+void 
+HpinDrvrLoad::setDrvr(Pin *drvr)
+{
+  drvr_ = drvr;
+}
+
+bool
+HpinDrvrLoadLess::operator()(const HpinDrvrLoad *drvr_load1,
+			     const HpinDrvrLoad *drvr_load2) const
+{
+  Pin *load1 = drvr_load1->load();
+  Pin *load2 = drvr_load2->load();
+  if (load1 == load2) {
+    Pin *drvr1 = drvr_load1->drvr();
+    Pin *drvr2 = drvr_load2->drvr();
+    return drvr1 < drvr2;
   }
-  else {
+  else
-    if (network->isDriver(pin)) {
+    return load1 < load2;
-      HpinDrvrLoad drvr(const_cast<Pin*>(pin), nullptr, &hpin_path, nullptr);
-      HpinDrvrLoads drvrs;
-      drvrs.insert(&drvr);
-      visitHpinDrvrLoads(drvrs, below_loads, visitor);
-      visitHpinDrvrLoads(drvrs, above_loads, visitor);
-    }
-    // Bidirects are drivers and loads.
-    if (network->isLoad(pin)) {
-      HpinDrvrLoad load(nullptr, const_cast<Pin*>(pin), nullptr, &hpin_path);
-      HpinDrvrLoads loads;
-      loads.insert(&load);
-      visitHpinDrvrLoads(below_drvrs, loads, visitor);
-      visitHpinDrvrLoads(above_drvrs, loads, visitor);
-    }
-  }
-  above_drvrs.deleteContents();
-  above_loads.deleteContents();
-  below_drvrs.deleteContents();
-  below_loads.deleteContents();
 }
 
 } // namespace

network/HpinDrvrLoad.hh

@@ -23,6 +23,12 @@
 namespace sta {
 
 class HpinDrvrLoad;
+class HpinDrvrLoadVisitor;
+
+void
+visitHpinDrvrLoads(const Pin *pin,
+		   const Network *network,
+		   HpinDrvrLoadVisitor *visitor);
 
 class HpinDrvrLoadLess
 { 
@@ -69,11 +75,6 @@ private:
   PinSet *hpins_to_load_;
 };
 
-void
-visitHpinDrvrLoads(const Pin *pin,
-		   const Network *network,
-		   HpinDrvrLoadVisitor *visitor);
-
 } // namespace
 #endif