Merge pull request #144 from openroadie/master

Sync to latest OpenSTA

CMakeLists.txt

@@ -1,5 +1,5 @@
 # OpenSTA, Static Timing Analyzer
-# Copyright (c) 2022, Parallax Software, Inc.
+# Copyright (c) 2023, Parallax Software, Inc.
 # 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by

README.md

@@ -211,7 +211,7 @@ is also licensed for commerical applications by Parallax Software without
 the GPL's requirements.
 
 OpenSTA, Static Timing Analyzer
-Copyright (c) 2022, Parallax Software, Inc.
+Copyright (c) 2023, Parallax Software, Inc.
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by

app/Main.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

app/StaApp.i

@@ -1,7 +1,7 @@
 %module sta
 
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

app/StaMain.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/ArcDelayCalc.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/Arnoldi.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/ArnoldiDelayCalc.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/ArnoldiDelayCalc.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/ArnoldiReduce.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/ArnoldiReduce.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/DcalcAnalysisPt.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/DelayCalc.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/DelayCalc.i

@@ -3,7 +3,7 @@
 %{
 
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/DelayCalc.tcl

@@ -1,5 +1,5 @@
 # OpenSTA, Static Timing Analyzer
-# Copyright (c) 2022, Parallax Software, Inc.
+# Copyright (c) 2023, Parallax Software, Inc.
 # 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by

dcalc/DmpCeff.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -265,8 +265,8 @@ protected:
   double *p_;
   int *index_;
 
-  // Gate slew used to check load delay.
-  double gate_slew_;
+  // Driver slew used to check load delay.
+  double drvr_slew_;
   double vo_delay_;
   // True if the driver parameters are valid for finding the load delays.
   bool driver_valid_;
@@ -565,9 +565,9 @@ DmpAlg::loadDelaySlew(const Pin *,
   if (!driver_valid_
       || elmore == 0.0
       // Elmore delay is small compared to driver slew.
-      || elmore < gate_slew_ * 1e-3) {
+      || elmore < drvr_slew_ * 1e-3) {
     delay = elmore;
-    slew = gate_slew_;
+    slew = drvr_slew_;
   }
   else {
     // Use the driver thresholds and rely on thresholdAdjust to
@@ -591,18 +591,18 @@ DmpAlg::loadDelaySlew(const Pin *,
 	// Use elmore delay.
 	delay1 = elmore;
       }
-      if (slew1 < gate_slew_) {
+      if (slew1 < drvr_slew_) {
 	// Only report a problem if the difference is significant.
-	if ((gate_slew_ - slew1) > vth_time_tol * gate_slew_)
+	if ((drvr_slew_ - slew1) > vth_time_tol * drvr_slew_)
 	  fail("load slew less than driver slew");
-	slew1 = gate_slew_;
+	slew1 = drvr_slew_;
       }
       delay = delay1;
       slew = slew1;
     }
     catch (DmpError &error) {
       delay = elmore_;
-      slew = gate_slew_;
+      slew = drvr_slew_;
     }
   }
 }
@@ -746,7 +746,7 @@ DmpCap::gateDelaySlew(double &delay,
   debugPrint(debug_, "dmp_ceff", 3, "    ceff = %s",
              units_->capacitanceUnit()->asString(ceff_));
   gateCapDelaySlew(ceff_, delay, slew);
-  gate_slew_ = slew;
+  drvr_slew_ = slew;
 }
 
 void
@@ -756,7 +756,7 @@ DmpCap::loadDelaySlew(const Pin *,
 		      Slew &slew)
 {
   delay = elmore;
-  slew = gate_slew_;
+  slew = drvr_slew_;
 }
 
 void
@@ -932,7 +932,7 @@ DmpPi::gateDelaySlew(double &delay,
     ceff_ = c1_ + c2_;
     gateCapDelaySlew(ceff_, delay, slew);
   }
-  gate_slew_ = slew;
+  drvr_slew_ = slew;
 }
 
 void
@@ -1223,7 +1223,7 @@ DmpZeroC2::gateDelaySlew(double &delay,
     ceff_ = c1_;
     gateCapDelaySlew(ceff_, delay, slew);
   }
-  gate_slew_ = slew;
+  drvr_slew_ = slew;
 }
 
 double

dcalc/DmpCeff.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/DmpDelayCalc.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/DmpDelayCalc.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/GraphDelayCalc.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/GraphDelayCalc1.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -73,7 +73,7 @@ public:
 	       float &pin_cap,
 	       float &wire_cap,
 	       float &fanout,
-	       bool &has_set_load);
+	       bool &has_net_load);
   void findCaps(const GraphDelayCalc1 *dcalc,
 		const Sdc *sdc);
 
@@ -162,7 +162,7 @@ MultiDrvrNet::netCaps(const RiseFall *drvr_rf,
 		      float &pin_cap,
 		      float &wire_cap,
 		      float &fanout,
-		      bool &has_set_load)
+		      bool &has_net_load)
 {
   int index = dcalc_ap->index() * RiseFall::index_count
     + drvr_rf->index();
@@ -170,7 +170,7 @@ MultiDrvrNet::netCaps(const RiseFall *drvr_rf,
   pin_cap = net_caps.pinCap();
   wire_cap = net_caps.wireCap();
   fanout = net_caps.fanout();
-  has_set_load = net_caps.hasSetLoad();
+  has_net_load = net_caps.hasSetLoad();
 }
 
 void
@@ -191,11 +191,11 @@ MultiDrvrNet::findCaps(const GraphDelayCalc1 *dcalc,
       int index = ap_index * RiseFall::index_count + drvr_rf_index;
       NetCaps &net_caps = net_caps_[index];
       float pin_cap, wire_cap, fanout;
-      bool has_set_load;
+      bool has_net_load;
       // Find pin and external pin/wire capacitance.
       sdc->connectedCap(drvr_pin, drvr_rf, op_cond, corner, min_max,
-			pin_cap, wire_cap, fanout, has_set_load);
-      net_caps.init(pin_cap, wire_cap, fanout, has_set_load);
+			pin_cap, wire_cap, fanout, has_net_load);
+      net_caps.init(pin_cap, wire_cap, fanout, has_net_load);
     }
   }
 }
@@ -1077,15 +1077,15 @@ GraphDelayCalc1::loadCap(const Pin *drvr_pin,
 			 const DcalcAnalysisPt *dcalc_ap) const
 {
   float pin_cap, wire_cap;
-  bool has_set_load;
+  bool has_net_load;
   float fanout;
   if (multi_drvr)
     multi_drvr->netCaps(rf, dcalc_ap,
-			pin_cap, wire_cap, fanout, has_set_load);
+			pin_cap, wire_cap, fanout, has_net_load);
   else
     netCaps(drvr_pin, rf, dcalc_ap,
-	    pin_cap, wire_cap, fanout, has_set_load);
-  loadCap(drvr_parasitic, has_set_load, pin_cap, wire_cap);
+	    pin_cap, wire_cap, fanout, has_net_load);
+  loadCap(drvr_parasitic, has_net_load, pin_cap, wire_cap);
   return wire_cap + pin_cap;
 }
 
@@ -1098,23 +1098,23 @@ GraphDelayCalc1::loadCap(const Pin *drvr_pin,
 			 float &pin_cap,
 			 float &wire_cap) const
 {
-  bool has_set_load;
+  bool has_net_load;
   float fanout;
   // Find pin and external pin/wire capacitance.
   netCaps(drvr_pin, rf, dcalc_ap,
-	  pin_cap, wire_cap, fanout, has_set_load);
-  loadCap(drvr_parasitic, has_set_load, pin_cap, wire_cap);
+	  pin_cap, wire_cap, fanout, has_net_load);
+  loadCap(drvr_parasitic, has_net_load, pin_cap, wire_cap);
 }
 
 void
 GraphDelayCalc1::loadCap(Parasitic *drvr_parasitic,
-			 bool has_set_load,
+			 bool has_net_load,
 			 // Return values.
 			 float &pin_cap,
 			 float &wire_cap) const
 {
-  // set_load has precidence over parasitics.
-  if (!has_set_load && drvr_parasitic) {
+  // set_load net has precidence over parasitics.
+  if (!has_net_load && drvr_parasitic) {
     if (parasitics_->isParasiticNetwork(drvr_parasitic))
       wire_cap += parasitics_->capacitance(drvr_parasitic);
     else {
@@ -1138,7 +1138,7 @@ GraphDelayCalc1::netCaps(const Pin *drvr_pin,
 			 float &pin_cap,
 			 float &wire_cap,
 			 float &fanout,
-			 bool &has_set_load) const
+			 bool &has_net_load) const
 {
   MultiDrvrNet *multi_drvr = nullptr;
   if (graph_) {
@@ -1147,14 +1147,14 @@ GraphDelayCalc1::netCaps(const Pin *drvr_pin,
   }
   if (multi_drvr)
     multi_drvr->netCaps(rf, dcalc_ap,
-			pin_cap, wire_cap, fanout, has_set_load);
+			pin_cap, wire_cap, fanout, has_net_load);
   else {
     const OperatingConditions *op_cond = dcalc_ap->operatingConditions();
     const Corner *corner = dcalc_ap->corner();
     const MinMax *min_max = dcalc_ap->constraintMinMax();
     // Find pin and external pin/wire capacitance.
     sdc_->connectedCap(drvr_pin, rf, op_cond, corner, min_max,
-		       pin_cap, wire_cap, fanout, has_set_load);
+		       pin_cap, wire_cap, fanout, has_net_load);
   }
 }
 

dcalc/GraphDelayCalc1.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/LumpedCapDelayCalc.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/LumpedCapDelayCalc.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/NetCaps.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/NetCaps.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/RCDelayCalc.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/RCDelayCalc.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/SimpleRCDelayCalc.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/SimpleRCDelayCalc.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/UnitDelayCalc.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

dcalc/UnitDelayCalc.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

doc/ApiChanges.txt

@@ -1,5 +1,5 @@
 # OpenSTA, Static Timing Analyzer
-# Copyright (c) 2022, Parallax Software, Inc.
+# Copyright (c) 2023, Parallax Software, Inc.
 # 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by

doc/StaApi.txt

@@ -1,5 +1,5 @@
 # OpenSTA, Static Timing Analyzer
-# Copyright (c) 2022, Parallax Software, Inc.
+# Copyright (c) 2023, Parallax Software, Inc.
 # 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by

etc/TclEncode.tcl

@@ -3,7 +3,7 @@
 exec tclsh $0 ${1+"$@"}
 
 # OpenSTA, Static Timing Analyzer
-# Copyright (c) 2022, Parallax Software, Inc.
+# Copyright (c) 2023, Parallax Software, Inc.
 # 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by

graph/Delay.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

graph/DelayFloat.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

graph/DelayNormal1.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

graph/DelayNormal2.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

graph/Graph.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

graph/GraphCmp.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/ArcDelayCalc.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/ArrayTable.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Bfs.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/ClkNetwork.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Clock.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/ClockGatingCheck.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/ClockGroups.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/ClockInsertion.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/ClockLatency.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/ConcreteLibrary.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/ConcreteNetwork.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -53,185 +53,181 @@ class ConcreteNetwork : public NetworkReader
 {
 public:
   ConcreteNetwork();
-  virtual ~ConcreteNetwork();
-  virtual void clear();
-  virtual bool linkNetwork(const char *top_cell_name,
-			   bool make_black_boxes,
-			   Report *report);
-  virtual Instance *topInstance() const;
+  ~ConcreteNetwork();
+  void clear() override;
+  bool linkNetwork(const char *top_cell_name,
+                   bool make_black_boxes,
+                   Report *report) override;
+  Instance *topInstance() const override;
 
-  virtual const char *name(const Library *library) const;
-  virtual ObjectId id(const Library *library) const;
-  virtual LibraryIterator *libraryIterator() const;
-  virtual LibertyLibraryIterator *libertyLibraryIterator() const ;
-  virtual Library *findLibrary(const char *name);
-  virtual LibertyLibrary *findLiberty(const char *name);
-  virtual LibertyLibrary *libertyLibrary(Library *library) const;
-  virtual Cell *findCell(const Library *library,
-			 const char *name) const;
-  virtual Cell *findAnyCell(const char *name);
-  virtual CellSeq findCellsMatching(const Library *library,
-                                    const PatternMatch *pattern) const;
+  const char *name(const Library *library) const override;
+  ObjectId id(const Library *library) const override;
+  LibraryIterator *libraryIterator() const override;
+  LibertyLibraryIterator *libertyLibraryIterator() const override;
+  Library *findLibrary(const char *name) override;
+  LibertyLibrary *findLiberty(const char *name) override;
+  Cell *findCell(const Library *library,
+                 const char *name) const override;
+  Cell *findAnyCell(const char *name) override;
+  CellSeq findCellsMatching(const Library *library,
+                            const PatternMatch *pattern) const override;
 
-  virtual const char *name(const Cell *cell) const;
-  virtual ObjectId id(const Cell *cell) const;
-  virtual Library *library(const Cell *cell) const;
-  virtual LibertyCell *libertyCell(Cell *cell) const;
-  virtual const LibertyCell *libertyCell(const Cell *cell) const;
-  virtual Cell *cell(LibertyCell *cell) const;
-  virtual const Cell *cell(const LibertyCell *cell) const;
-  virtual const char *filename(const Cell *cell);
-  virtual Port *findPort(const Cell *cell,
-			 const char *name) const;
-  virtual PortSeq findPortsMatching(const Cell *cell,
-				 const PatternMatch *pattern) const;
-  virtual bool isLeaf(const Cell *cell) const;
-  virtual CellPortIterator *portIterator(const Cell *cell) const;
-  virtual CellPortBitIterator *portBitIterator(const Cell *cell) const;
-  virtual int portBitCount(const Cell *cell) const;
+  const char *name(const Cell *cell) const override;
+  ObjectId id(const Cell *cell) const override;
+  Library *library(const Cell *cell) const override;
+  LibertyCell *libertyCell(Cell *cell) const override;
+  const LibertyCell *libertyCell(const Cell *cell) const override;
+  Cell *cell(LibertyCell *cell) const override;
+  const Cell *cell(const LibertyCell *cell) const override;
+  const char *filename(const Cell *cell) override;
+  Port *findPort(const Cell *cell,
+                 const char *name) const override;
+  PortSeq findPortsMatching(const Cell *cell,
+                            const PatternMatch *pattern) const override;
+  bool isLeaf(const Cell *cell) const override;
+  CellPortIterator *portIterator(const Cell *cell) const override;
+  CellPortBitIterator *portBitIterator(const Cell *cell) const override;
+  int portBitCount(const Cell *cell) const override;
 
-  virtual const char *name(const Port *port) const;
-  virtual ObjectId id(const Port *port) const;
-  virtual Cell *cell(const Port *port) const;
-  virtual LibertyPort *libertyPort(const Port *port) const;
-  virtual PortDirection *direction(const Port *port) const;
-  virtual bool isBundle(const Port *port) const;
-  virtual bool hasMembers(const Port *port) const;
+  const char *name(const Port *port) const override;
+  ObjectId id(const Port *port) const override;
+  Cell *cell(const Port *port) const override;
+  LibertyPort *libertyPort(const Port *port) const override;
+  PortDirection *direction(const Port *port) const override;
+  bool isBundle(const Port *port) const override;
+  bool hasMembers(const Port *port) const override;
 
-  virtual bool isBus(const Port *port) const;
-  virtual int size(const Port *port) const;
-  virtual const char *busName(const Port *port) const;
-  virtual Port *findBusBit(const Port *port,
-			   int index) const;
-  virtual int fromIndex(const Port *port) const;
-  virtual int toIndex(const Port *port) const;
-  virtual Port *findMember(const Port *port,
-			   int index) const;
-  virtual PortMemberIterator *memberIterator(const Port *port) const;
+  bool isBus(const Port *port) const override;
+  int size(const Port *port) const override;
+  const char *busName(const Port *port) const override;
+  Port *findBusBit(const Port *port,
+                   int index) const override;
+  int fromIndex(const Port *port) const override;
+  int toIndex(const Port *port) const override;
+  Port *findMember(const Port *port,
+                   int index) const override;
+  PortMemberIterator *memberIterator(const Port *port) const override;
 
-  virtual const char *name(const Instance *instance) const;
-  virtual ObjectId id(const Instance *instance) const;
-  virtual Cell *cell(const Instance *instance) const;
-  virtual Instance *parent(const Instance *instance) const;
-  virtual bool isLeaf(const Instance *instance) const;
-  virtual Instance *findChild(const Instance *parent,
-			      const char *name) const;
-  virtual Pin *findPin(const Instance *instance,
-		       const char *port_name) const;
-  virtual Pin *findPin(const Instance *instance,
-		       const Port *port) const;
+  const char *name(const Instance *instance) const override;
+  ObjectId id(const Instance *instance) const override;
+  Cell *cell(const Instance *instance) const override;
+  Instance *parent(const Instance *instance) const override;
+  bool isLeaf(const Instance *instance) const override;
+  Instance *findChild(const Instance *parent,
+                      const char *name) const override;
+  Pin *findPin(const Instance *instance,
+               const char *port_name) const override;
+  Pin *findPin(const Instance *instance,
+               const Port *port) const override;
 
-  virtual InstanceChildIterator *
-  childIterator(const Instance *instance) const;
-  virtual InstancePinIterator *
-  pinIterator(const Instance *instance) const;
-  virtual InstanceNetIterator *
-  netIterator(const Instance *instance) const;
+  InstanceChildIterator *
+  childIterator(const Instance *instance) const override;
+  InstancePinIterator *
+  pinIterator(const Instance *instance) const override;
+  InstanceNetIterator *
+  netIterator(const Instance *instance) const override;
 
-  virtual ObjectId id(const Pin *pin) const;
-  virtual Instance *instance(const Pin *pin) const;
-  virtual Net *net(const Pin *pin) const;
-  virtual Term *term(const Pin *pin) const;
-  virtual Port *port(const Pin *pin) const;
-  virtual PortDirection *direction(const Pin *pin) const;
-  virtual VertexId vertexId(const Pin *pin) const;
-  virtual void setVertexId(Pin *pin,
-			   VertexId id);
+  ObjectId id(const Pin *pin) const override;
+  Instance *instance(const Pin *pin) const override;
+  Net *net(const Pin *pin) const override;
+  Term *term(const Pin *pin) const override;
+  Port *port(const Pin *pin) const override;
+  PortDirection *direction(const Pin *pin) const override;
+  VertexId vertexId(const Pin *pin) const override;
+  void setVertexId(Pin *pin,
+                   VertexId id) override;
 
-  virtual ObjectId id(const Term *term) const;
-  virtual Net *net(const Term *term) const;
-  virtual Pin *pin(const Term *term) const;
+  ObjectId id(const Term *term) const override;
+  Net *net(const Term *term) const override;
+  Pin *pin(const Term *term) const override;
 
-  virtual const char *name(const Net *net) const;
-  virtual ObjectId id(const Net *net) const;
-  virtual Net *findNet(const Instance *instance,
-		       const char *net_name) const;
-  virtual void findInstNetsMatching(const Instance *instance,
-                                    const PatternMatch *pattern,
-                                    NetSeq &matches) const;
-  virtual Instance *instance(const Net *net) const;
-  virtual bool isPower(const Net *net) const;
-  virtual bool isGround(const Net *net) const;
-  virtual NetPinIterator *pinIterator(const Net *net) const;
-  virtual NetTermIterator *termIterator(const Net *net) const;
-  virtual void mergeInto(Net *net,
-			 Net *into_net);
-  virtual Net *mergedInto(Net *net);
+  const char *name(const Net *net) const override;
+  ObjectId id(const Net *net) const override;
+  Net *findNet(const Instance *instance,
+               const char *net_name) const override;
+  void findInstNetsMatching(const Instance *instance,
+                            const PatternMatch *pattern,
+                            NetSeq &matches) const override;
+  Instance *instance(const Net *net) const override;
+  bool isPower(const Net *net) const override;
+  bool isGround(const Net *net) const override;
+  NetPinIterator *pinIterator(const Net *net) const override;
+  NetTermIterator *termIterator(const Net *net) const override;
+  void mergeInto(Net *net,
+                 Net *into_net) override;
+  Net *mergedInto(Net *net) override;
 
-  virtual ConstantPinIterator *constantPinIterator();
+  ConstantPinIterator *constantPinIterator() override;
   void addConstantNet(Net *net,
-		      LogicValue value);
+		      LogicValue value) override;
 
   // Edit methods.
-  virtual Library *makeLibrary(const char *name,
-			       const char *filename);
-  virtual LibertyLibrary *makeLibertyLibrary(const char *name,
-					     const char *filename);
-  virtual void deleteLibrary(Library *library);
-  virtual Cell *makeCell(Library *library,
-			 const char *name,
-			 bool is_leaf,
-			 const char *filename);
-  virtual void deleteCell(Cell *cell);
-  virtual void setName(Cell *cell,
-		       const char *name);
-  virtual void setIsLeaf(Cell *cell,
-			 bool is_leaf);
-  virtual Port *makePort(Cell *cell,
-			 const char *name);
-  virtual Port *makeBusPort(Cell *cell,
-			    const char *name,
-			    int from_index,
-			    int to_index);
-  virtual void groupBusPorts(Cell *cell,
-                             std::function<bool(const char*)> port_msb_first);
-  virtual Port *makeBundlePort(Cell *cell,
-			       const char *name,
-			       PortSeq *members);
-  virtual void setDirection(Port *port,
-			    PortDirection *dir);
+  Library *makeLibrary(const char *name,
+                       const char *filename) override;
+  LibertyLibrary *makeLibertyLibrary(const char *name,
+                                     const char *filename) override;
+  void deleteLibrary(Library *library) override;
+  Cell *makeCell(Library *library,
+                 const char *name,
+                 bool is_leaf,
+                 const char *filename) override;
+  void deleteCell(Cell *cell) override;
+  void setName(Cell *cell,
+               const char *name) override;
+  void setIsLeaf(Cell *cell,
+                 bool is_leaf) override;
+  Port *makePort(Cell *cell,
+                 const char *name) override;
+  Port *makeBusPort(Cell *cell,
+                    const char *name,
+                    int from_index,
+                    int to_index) override;
+  void groupBusPorts(Cell *cell,
+                     std::function<bool(const char*)> port_msb_first) override;
+  Port *makeBundlePort(Cell *cell,
+                       const char *name,
+                       PortSeq *members) override;
+  void setDirection(Port *port,
+                    PortDirection *dir) override;
   // For NetworkEdit.
-  virtual Instance *makeInstance(LibertyCell *cell,
-				 const char *name,
-				 Instance *parent);
-  void makePins(Instance *inst);
+  Instance *makeInstance(LibertyCell *cell,
+                         const char *name,
+                         Instance *parent) override;
+  void makePins(Instance *inst) override;
   // For linking.
-  virtual Instance *makeInstance(Cell *cell,
-				 const char *name,
-				 Instance *parent);
-  virtual void replaceCell(Instance *inst,
-			   Cell *cell);
-  virtual void deleteInstance(Instance *inst);
-  virtual Pin *connect(Instance *inst,
-		       Port *port,
-		       Net *net);
-  virtual Pin *connect(Instance *inst,
-		       LibertyPort *port,
-		       Net *net);
-  virtual void disconnectPin(Pin *pin);
-  virtual void deletePin(Pin *pin);
-  virtual Net *makeNet(const char *name,
-		       Instance *parent);
-  virtual void deleteNet(Net *net);
+  Instance *makeInstance(Cell *cell,
+                         const char *name,
+                         Instance *parent) override;
+  void replaceCell(Instance *inst,
+                   Cell *cell) override;
+  void deleteInstance(Instance *inst) override;
+  Pin *connect(Instance *inst,
+               Port *port,
+               Net *net) override;
+  Pin *connect(Instance *inst,
+               LibertyPort *port,
+               Net *net) override;
+  void disconnectPin(Pin *pin) override;
+  void deletePin(Pin *pin) override;
+  Net *makeNet(const char *name,
+               Instance *parent) override;
+  void deleteNet(Net *net) override;
 
   // For NetworkReader API.
-  virtual Term *makeTerm(Pin *pin,
-			 Net *net);
-  virtual Pin *makePin(Instance *inst,
-		       Port *port,
-		       Net *net);
+  Term *makeTerm(Pin *pin,
+                 Net *net) override;
+  Pin *makePin(Instance *inst,
+               Port *port,
+               Net *net) override;
 
   // Instance is the network view for cell.
-  virtual void setCellNetworkView(Cell *cell,
-				  Instance *inst);
-  virtual Instance *cellNetworkView(Cell *cell);
-  virtual void deleteCellNetworkViews();
-  void deleteTopInstance();
-
-  virtual void readNetlistBefore();
-  virtual void setLinkFunc(LinkNetworkFunc *link);
-  void setTopInstance(Instance *top_inst);
+  void setCellNetworkView(Cell *cell,
+                          Instance *inst) override;
+  Instance *cellNetworkView(Cell *cell) override;
+  void deleteCellNetworkViews() override;
 
+  void readNetlistBefore() override;
+  void setLinkFunc(LinkNetworkFunc *link) override;
   static ObjectId nextObjectId();
 
   using Network::netIterator;
@@ -244,12 +240,14 @@ public:
   using Network::isLeaf;
 
 protected:
+  void setTopInstance(Instance *top_inst);
+  void deleteTopInstance();
   void addLibrary(ConcreteLibrary *library);
   void setName(const char *name);
   void clearConstantNets();
-  virtual void visitConnectedPins(const Net *net,
-				  PinVisitor &visitor,
-				  NetSet &visited_nets) const;
+  void visitConnectedPins(const Net *net,
+                          PinVisitor &visitor,
+                          NetSet &visited_nets) const override;
   Instance *makeConcreteInstance(ConcreteCell *cell,
 				 const char *name,
 				 Instance *parent);

include/sta/Corner.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/CycleAccting.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/DataCheck.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/DcalcAnalysisPt.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Debug.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Delay.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/DelayCalc.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/DelayFloat.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/DelayNormal1.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/DelayNormal2.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/DeratingFactors.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/DisabledPorts.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/EnumNameMap.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/EquivCells.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Error.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/ExceptionPath.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/FuncExpr.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Fuzzy.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Graph.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/GraphClass.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/GraphCmp.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/GraphDelayCalc.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Hash.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/HpinDrvrLoad.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/InputDrive.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/InternalPower.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Iterator.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/LeakagePower.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Liberty.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -85,7 +85,7 @@ enum class DelayModelType { cmos_linear, cmos_pwl, cmos2, table, polynomial, dcm
 enum class ScaleFactorPvt { process, volt, temp, unknown };
 constexpr int scale_factor_pvt_count = int(ScaleFactorPvt::unknown) + 1;
 
-enum class TableTemplateType { delay, power, output_current, ocv };
+enum class TableTemplateType { delay, power, output_current, capacitance, ocv };
 constexpr int table_template_type_count = int(TableTemplateType::ocv) + 1;
 
 enum class LevelShifterType { HL, LH, HL_LH };
@@ -778,6 +778,8 @@ public:
   void setRelatedGroundPin(const char *related_ground_pin);
   const char *relatedPowerPin() const { return related_power_pin_; }
   void setRelatedPowerPin(const char *related_power_pin);
+  ReceiverModelPtr receiverModel() const { return receiver_model_; }
+  void setReceiverModel(ReceiverModelPtr receiver_model);
 
   static bool equiv(const LibertyPort *port1,
 		    const LibertyPort *port2);
@@ -817,6 +819,7 @@ protected:
   const char *related_ground_pin_;
   const char *related_power_pin_;
   Vector<LibertyPort*> corner_ports_;
+  ReceiverModelPtr receiver_model_;
 
   unsigned int min_pulse_width_exists_:RiseFall::index_count;
   bool min_period_exists_:1;
@@ -1090,4 +1093,7 @@ private:
   LibertyCell *cell_;
 };
 
+const char *
+portLibertyToSta(const char *port_name);
+
 } // namespace

include/sta/LibertyClass.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -57,6 +57,7 @@ class TimingRole;
 class Transition;
 class RiseFall;
 class RiseFallBoth;
+class ReceiverModel;
 
 typedef Vector<LibertyLibrary*> LibertyLibrarySeq;
 typedef Vector<LibertyCell*> LibertyCellSeq;
@@ -66,11 +67,10 @@ typedef Vector<LibertyPort*> LibertyPortSeq;
 typedef Set<LibertyPort*> LibertyPortSet;
 typedef std::pair<const LibertyPort*,const LibertyPort*> LibertyPortPair;
 typedef Set<LibertyCell*> LibertyCellSet;
-typedef Vector<float> FloatSeq;
-typedef Vector<FloatSeq*> FloatTable;
 typedef std::shared_ptr<Table> TablePtr;
 typedef std::shared_ptr<TimingArcAttrs> TimingArcAttrsPtr;
 typedef std::shared_ptr<TableAxis> TableAxisPtr;
+typedef std::shared_ptr<ReceiverModel> ReceiverModelPtr;
 
 enum class ScaleFactorType : unsigned {
   pin_cap,

include/sta/LibertyWriter.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/LinearModel.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Machine.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/MakeConcreteNetwork.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/MakeConcreteParasitics.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Map.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/MinMax.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/MinMaxValues.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Mutex.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Network.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/NetworkClass.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/NetworkCmp.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/NullParasitics.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/ObjectId.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/ObjectTable.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

include/sta/Parasitics.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2022, Parallax Software, Inc.
+// Copyright (c) 2023, Parallax Software, Inc.
 // 
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by