Merge pull request #311 from The-OpenROAD-Project-staging/sta_update_latest_upstream_master

Sta update latest upstream master

.clang-format

@@ -22,7 +22,7 @@ BreakBeforeBinaryOperators: NonAssignment
 BreakBeforeBraces: Custom
 # fails if all initializers fit on one line
 BreakConstructorInitializers: AfterColon
-ColumnLimit: 90
+ColumnLimit: 85
 # fails
 ConstructorInitializerIndentWidth: 2
 IncludeBlocks: Preserve

Dockerfile.centos7

@@ -11,7 +11,7 @@ RUN sed -i s/mirror.centos.org/vault.centos.org/g /etc/yum.repos.d/*.repo \
 RUN sed -i s/mirror.centos.org/vault.centos.org/g /etc/yum.repos.d/*.repo \
     && sed -i s/^#.*baseurl=http/baseurl=http/g /etc/yum.repos.d/*.repo \
     && sed -i s/^mirrorlist=http/#mirrorlist=http/g /etc/yum.repos.d/*.repo \ 
-    && yum install -y devtoolset-11 wget cmake3 make eigen3-devel tcl swig3 flex zlib-devel valgrind \
+    && yum install -y devtoolset-11 git wget cmake3 make eigen3-devel tcl swig3 flex zlib-devel valgrind \
     && yum clean -y all
 
 RUN ln -sf /usr/bin/cmake3 /usr/bin/cmake

README.md

@@ -184,13 +184,23 @@ files in the build directory.
 
 ## Build with Docker
 
-An alternative way to build and run OpenSTA is with
+AN alternative way to build and run OpenSTA is with
 [Docker](https://www.docker.com).  After installing Docker, the
 following command builds a Docker image.
 
 ```
 cd OpenSTA
 docker build --file Dockerfile.ubuntu22.04 --tag opensta_ubuntu22.04 .
+or
+docker build --file Dockerfile.centos7 --tag opensta_centos7 .
+```
+
+The centos7 build on mac/OsX with ARM processorts requires the platform
+to be specified.
+
+```
+docker build --file Dockerfile.centos7 --platform=linux/amd64 --tag opensta_centos7 .
+
 ```
 
 To run a docker container using the OpenSTA image, use the -v option

app/StaMain.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/ArcDcalcWaveforms.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/ArcDcalcWaveforms.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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
@@ -119,7 +119,7 @@ class ArnoldiDelayCalc : public LumpedCapDelayCalc
 {
 public:
   ArnoldiDelayCalc(StaState *sta);
-  virtual ~ArnoldiDelayCalc();
+  ~ArnoldiDelayCalc() override;
   ArcDelayCalc *copy() override;
   const char *name() const override { return "arnoldi"; }
   Parasitic *findParasitic(const Pin *drvr_pin,

dcalc/ArnoldiDelayCalc.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/CcsCeffDelayCalc.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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
@@ -340,8 +340,8 @@ CcsCeffDelayCalc::loadDelaySlew(const Pin *load_pin,
                                 ArcDelay &wire_delay,
                                 Slew &load_slew)
 {
-  ArcDelay wire_delay1 = 0.0;
-  Slew load_slew1 = drvr_slew;
+  wire_delay = 0.0;
+  load_slew = drvr_slew;
   bool elmore_exists = false;
   float elmore = 0.0;
   if (parasitic_
@@ -352,15 +352,13 @@ CcsCeffDelayCalc::loadDelaySlew(const Pin *load_pin,
       (elmore == 0.0
        // Elmore delay is small compared to driver slew.
        || elmore < delayAsFloat(drvr_slew) * 1e-3)) {
-    wire_delay1 = elmore;
-    load_slew1 = drvr_slew;
+    wire_delay = elmore;
+    load_slew = drvr_slew;
   }
   else
-    loadDelaySlew(load_pin, drvr_slew, elmore, wire_delay1, load_slew1);
+    loadDelaySlew(load_pin, drvr_slew, elmore, wire_delay, load_slew);
 
   thresholdAdjust(load_pin, drvr_library, rf, wire_delay, load_slew);
-  wire_delay = wire_delay1;
-  load_slew = load_slew1;
 }
 
 void

dcalc/CcsCeffDelayCalc.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+# Copyright (c) 2026, 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/DelayCalcBase.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/DelayCalcBase.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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
@@ -77,7 +77,6 @@ class DmpError : public Exception
 {
 public:
   DmpError(const char *what);
-  virtual ~DmpError() {}
   virtual const char *what() const noexcept { return what_; }
 
 private:

dcalc/DmpCeff.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/FindRoot.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/FindRoot.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/ParallelDelayCalc.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/ParallelDelayCalc.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/PrimaDelayCalc.cc

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/PrimaDelayCalc.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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
@@ -107,7 +107,7 @@ public:
                         int &bidirect_count,
                         int &load_count,
                         const Network *network);
-  virtual void operator()(const Pin *pin);
+  void operator()(const Pin *pin) override;
 
 protected:
   Pin *drvr_pin_;
@@ -345,8 +345,8 @@ public:
   MakeEdgesThruHierPin(Graph *graph);
 
 private:
-  virtual void visit(const Pin *drvr,
-                     const Pin *load);
+  void visit(const Pin *drvr,
+             const Pin *load) override;
 
   Graph *graph_;
 };
@@ -1483,8 +1483,8 @@ class FindEdgesThruHierPinVisitor : public HierPinThruVisitor
 public:
   FindEdgesThruHierPinVisitor(EdgeSet &edges,
                               Graph *graph);
-  virtual void visit(const Pin *drvr,
-                     const Pin *load);
+  void visit(const Pin *drvr,
+             const Pin *load) override;
   
 protected:
   EdgeSet &edges_;

graph/Graph.i

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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.tcl

@@ -1,5 +1,5 @@
 # OpenSTA, Static Timing Analyzer
-# Copyright (c) 2025, Parallax Software, Inc.
+# Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/Bdd.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/BoundedHeap.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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
@@ -27,6 +27,7 @@
 #include <vector>
 #include <algorithm>
 #include <functional>
+#include <optional>
 
 namespace sta {
 
@@ -118,13 +119,14 @@ public:
   // If the heap is not full, the element is added.
   // If the heap is full and the new element is better than the worst element,
   // the worst element is replaced. Otherwise, the element is ignored.
-  // Returns true if the element was inserted, false if it was ignored.
-  bool
+  // Returns (inserted, displaced): inserted is true if the element was inserted,
+  // displaced is set when an element was pushed out (caller must handle ownership).
+  std::pair<bool, std::optional<T>>
   insert(const T& value) {
     if (heap_.size() < max_size_) {
       heap_.push_back(value);
       std::push_heap(heap_.begin(), heap_.end(), min_heap_comp_);
-      return true;
+      return {true, std::nullopt};
     }
     else if (!heap_.empty()) {
       // When keeping N worst (smallest) values: if new value is smaller than worst,
@@ -134,23 +136,25 @@ public:
       if (comp_(value, heap_.front())) {
         // New value is smaller than worst - find and replace the largest element
         auto max_it = std::max_element(heap_.begin(), heap_.end(), comp_);
+        T displaced = std::move(*max_it);
         *max_it = value;
         // Rebuild heap since we modified an internal element
         std::make_heap(heap_.begin(), heap_.end(), min_heap_comp_);
-        return true;
+        return {true, std::move(displaced)};
       }
       // Otherwise, new value is >= worst, so we already have worse values - reject it
     }
-    return false;
+    return {false, std::nullopt};
   }
 
   // Insert an element using move semantics
-  bool insert(T&& value)
+  std::pair<bool, std::optional<T>>
+  insert(T&& value)
   {
     if (heap_.size() < max_size_) {
       heap_.push_back(std::move(value));
       std::push_heap(heap_.begin(), heap_.end(), min_heap_comp_);
-      return true;
+      return {true, std::nullopt};
     }
     else if (!heap_.empty()) {
       // When keeping N worst (smallest) values: if new value is smaller than worst,
@@ -160,14 +164,15 @@ public:
       if (comp_(value, heap_.front())) {
         // New value is smaller than worst - find and replace the largest element
         auto max_it = std::max_element(heap_.begin(), heap_.end(), comp_);
+        T displaced = std::move(*max_it);
         *max_it = std::move(value);
         // Rebuild heap since we modified an internal element
         std::make_heap(heap_.begin(), heap_.end(), min_heap_comp_);
-        return true;
+        return {true, std::move(displaced)};
       }
       // Otherwise, new value is >= worst, so we already have worse values - reject it
     }
-    return false;
+    return {false, std::nullopt};
   }
 
   // Extract all elements sorted from best to worst.

include/sta/CircuitSim.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/ContainerHelpers.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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
@@ -164,17 +164,17 @@ public:
             bool own_pts,
             int priority,
             const char *comment);
-  virtual ExceptionPath *clone(ExceptionFrom *from,
-                               ExceptionThruSeq *thrus,
-                               ExceptionTo *to,
-                               bool own_pts);
-  virtual bool isFalse() const { return true; }
-  virtual ExceptionPathType type() const { return ExceptionPathType::false_path; }
-  virtual const char *typeString() const;
-  virtual bool mergeable(ExceptionPath *exception) const;
-  virtual bool overrides(ExceptionPath *exception) const;
-  virtual int typePriority() const;
-  virtual bool tighterThan(ExceptionPath *exception) const;
+  ExceptionPath *clone(ExceptionFrom *from,
+                       ExceptionThruSeq *thrus,
+                       ExceptionTo *to,
+                       bool own_pts) override;
+  bool isFalse() const override { return true; }
+  ExceptionPathType type() const override { return ExceptionPathType::false_path; }
+  const char *typeString() const override;
+  bool mergeable(ExceptionPath *exception) const override;
+  bool overrides(ExceptionPath *exception) const override;
+  int typePriority() const override;
+  bool tighterThan(ExceptionPath *exception) const override;
 };
 
 // Loop paths are false paths used to disable paths around
@@ -184,10 +184,10 @@ class LoopPath : public FalsePath
 public:
   LoopPath(ExceptionThruSeq *thrus,
            bool own_pts);
-  virtual bool isLoop() const { return true; }
-  virtual ExceptionPathType type() const { return ExceptionPathType::loop; }
-  virtual const char *typeString() const;
-  virtual bool mergeable(ExceptionPath *exception) const;
+  bool isLoop() const override { return true; }
+  ExceptionPathType type() const override { return ExceptionPathType::loop; }
+  const char *typeString() const override;
+  bool mergeable(ExceptionPath *exception) const override;
 };
 
 // set_max_delay/set_min_delay
@@ -203,21 +203,21 @@ public:
             float delay,
             bool own_pts,
             const char *comment);
-  virtual ExceptionPath *clone(ExceptionFrom *from,
-                               ExceptionThruSeq *thrus,
-                               ExceptionTo *to,
-                               bool own_pts);
-  virtual bool isPathDelay() const { return true; }
-  virtual ExceptionPathType type() const { return ExceptionPathType::path_delay; }
-  virtual const char *asString(const Network *network) const;
-  virtual const char *typeString() const;
-  virtual bool mergeable(ExceptionPath *exception) const;
-  virtual bool overrides(ExceptionPath *exception) const;
-  virtual float delay() const { return delay_; }
-  virtual int typePriority() const;
-  virtual bool tighterThan(ExceptionPath *exception) const;
-  virtual bool ignoreClkLatency() const { return ignore_clk_latency_; }
-  virtual bool breakPath() const { return break_path_; }
+  ExceptionPath *clone(ExceptionFrom *from,
+                       ExceptionThruSeq *thrus,
+                       ExceptionTo *to,
+                       bool own_pts) override;
+  bool isPathDelay() const override { return true; }
+  ExceptionPathType type() const override { return ExceptionPathType::path_delay; }
+  const char *asString(const Network *network) const override;
+  const char *typeString() const override;
+  bool mergeable(ExceptionPath *exception) const override;
+  bool overrides(ExceptionPath *exception) const override;
+  float delay() const override { return delay_; }
+  int typePriority() const override;
+  bool tighterThan(ExceptionPath *exception) const override;
+  bool ignoreClkLatency() const override { return ignore_clk_latency_; }
+  bool breakPath() const override { return break_path_; }
 
 protected:
   bool ignore_clk_latency_;
@@ -237,24 +237,24 @@ public:
                  int path_multiplier,
                  bool own_pts,
                  const char *comment);
-  virtual ExceptionPath *clone(ExceptionFrom *from,
-                               ExceptionThruSeq *thrus,
-                               ExceptionTo *to,
-                               bool own_pts);
-  virtual bool isMultiCycle() const { return true; }
-  virtual ExceptionPathType type() const { return ExceptionPathType::multi_cycle; }
-  virtual bool matches(const MinMax *min_max,
-                       bool exactly) const;
-  virtual const char *asString(const Network *network) const;
-  virtual const char *typeString() const;
-  virtual bool mergeable(ExceptionPath *exception) const;
-  virtual bool overrides(ExceptionPath *exception) const;
-  virtual bool useEndClk() const { return use_end_clk_; }
-  virtual int pathMultiplier(const MinMax *min_max) const;
-  virtual int pathMultiplier() const { return path_multiplier_; }
-  virtual int priority(const MinMax *min_max) const;
-  virtual int typePriority() const;
-  virtual bool tighterThan(ExceptionPath *exception) const;
+  ExceptionPath *clone(ExceptionFrom *from,
+                       ExceptionThruSeq *thrus,
+                       ExceptionTo *to,
+                       bool own_pts) override;
+  bool isMultiCycle() const override { return true; }
+  ExceptionPathType type() const override { return ExceptionPathType::multi_cycle; }
+  bool matches(const MinMax *min_max,
+               bool exactly) const override;
+  const char *asString(const Network *network) const override;
+  const char *typeString() const override;
+  bool mergeable(ExceptionPath *exception) const override;
+  bool overrides(ExceptionPath *exception) const override;
+  bool useEndClk() const override { return use_end_clk_; }
+  int pathMultiplier(const MinMax *min_max) const;  // overload, not override
+  int pathMultiplier() const override { return path_multiplier_; }
+  int priority(const MinMax *min_max) const override;
+  int typePriority() const override;
+  bool tighterThan(ExceptionPath *exception) const override;
 
   using ExceptionPath::priority;
 
@@ -271,22 +271,22 @@ public:
              ExceptionThruSeq *thrus,
              ExceptionTo *to,
              bool own_pts);
-  virtual ExceptionPath *clone(ExceptionFrom *from,
-                               ExceptionThruSeq *thrus,
-                               ExceptionTo *to,
-                               bool own_pts);
-  virtual bool isFilter() const { return true; }
-  virtual ExceptionPathType type() const { return ExceptionPathType::filter; }
-  virtual const char *typeString() const;
-  virtual bool mergeable(ExceptionPath *exception) const;
-  virtual bool overrides(ExceptionPath *exception) const;
-  virtual bool resetMatch(ExceptionFrom *from,
-                          ExceptionThruSeq *thrus,
-                          ExceptionTo *to,
-                          const MinMaxAll *min_max,
-                          const Network *network);
-  virtual int typePriority() const;
-  virtual bool tighterThan(ExceptionPath *exception) const;
+  ExceptionPath *clone(ExceptionFrom *from,
+                       ExceptionThruSeq *thrus,
+                       ExceptionTo *to,
+                       bool own_pts) override;
+  bool isFilter() const override { return true; }
+  ExceptionPathType type() const override { return ExceptionPathType::filter; }
+  const char *typeString() const override;
+  bool mergeable(ExceptionPath *exception) const override;
+  bool overrides(ExceptionPath *exception) const override;
+  bool resetMatch(ExceptionFrom *from,
+                  ExceptionThruSeq *thrus,
+                  ExceptionTo *to,
+                  const MinMaxAll *min_max,
+                  const Network *network) override;
+  int typePriority() const override;
+  bool tighterThan(ExceptionPath *exception) const override;
 };
 
 class GroupPath : public ExceptionPath
@@ -299,20 +299,20 @@ public:
             ExceptionTo *to,
             bool own_pts,
             const char *comment);
-  virtual ~GroupPath();
-  virtual ExceptionPath *clone(ExceptionFrom *from,
-                               ExceptionThruSeq *thrus,
-                               ExceptionTo *to,
-                               bool own_pts);
-  virtual bool isGroupPath() const { return true; }
-  virtual ExceptionPathType type() const { return ExceptionPathType::group_path; }
-  virtual const char *typeString() const;
-  virtual bool mergeable(ExceptionPath *exception) const;
-  virtual bool overrides(ExceptionPath *exception) const;
-  virtual int typePriority() const;
-  virtual bool tighterThan(ExceptionPath *exception) const;
-  virtual const char *name()  const { return name_; }
-  virtual bool isDefault() const { return is_default_; }
+  ~GroupPath() override;
+  ExceptionPath *clone(ExceptionFrom *from,
+                       ExceptionThruSeq *thrus,
+                       ExceptionTo *to,
+                       bool own_pts) override;
+  bool isGroupPath() const override { return true; }
+  ExceptionPathType type() const override { return ExceptionPathType::group_path; }
+  const char *typeString() const override;
+  bool mergeable(ExceptionPath *exception) const override;
+  bool overrides(ExceptionPath *exception) const override;
+  int typePriority() const override;
+  bool tighterThan(ExceptionPath *exception) const override;
+  const char *name()  const override { return name_; }
+  bool isDefault() const override { return is_default_; }
 
 protected:
   const char *name_;
@@ -385,39 +385,39 @@ public:
                   bool own_pts,
                   const Network *network);
   ~ExceptionFromTo();
-  virtual PinSet *pins() { return pins_; }
+  PinSet *pins() override { return pins_; }
   bool hasPins() const;
-  ClockSet *clks() { return clks_; }
+  ClockSet *clks() override { return clks_; }
   bool hasClocks() const;
-  InstanceSet *instances() { return insts_; }
+  InstanceSet *instances() override { return insts_; }
   bool hasInstances() const;
-  virtual NetSet *nets() { return nullptr; }
-  virtual EdgePinsSet *edges() { return nullptr; }
+  NetSet *nets() override { return nullptr; }
+  EdgePinsSet *edges() override { return nullptr; }
   bool hasObjects() const;
   void deleteObjects(ExceptionFromTo *pt,
                      const Network *network);
-  virtual PinSet allPins(const Network *network);
+  PinSet allPins(const Network *network) override;
   bool equal(ExceptionFromTo *from_to) const;
-  virtual int compare(ExceptionPt *pt,
-                      const Network *network) const;
-  virtual void mergeInto(ExceptionPt *pt,
-                         const Network *network);
-  virtual const char *asString(const Network *network) const;
-  virtual size_t objectCount() const;
+  int compare(ExceptionPt *pt,
+              const Network *network) const override;
+  void mergeInto(ExceptionPt *pt,
+                 const Network *network) override;
+  const char *asString(const Network *network) const override;
+  size_t objectCount() const override;
   void deleteClock(Clock *clk);
-  virtual void addPin(const Pin *pin,
-                      const Network *network);
-  virtual void addClock(Clock *clk);
-  virtual void addInstance(const Instance *inst,
-                           const Network *network);
-  virtual void addNet(const Net *,
-                      const Network *) {}
-  virtual void addEdge(const EdgePins &,
-                       const Network *) {}
-  virtual void connectPinAfter(PinSet *,
-			       Network *) {}
-  virtual void deletePinBefore(const Pin *,
-                               Network *);
+  void addPin(const Pin *pin,
+              const Network *network) override;
+  void addClock(Clock *clk) override;
+  void addInstance(const Instance *inst,
+                   const Network *network) override;
+  void addNet(const Net *,
+              const Network *) override {}
+  void addEdge(const EdgePins &,
+               const Network *) override {}
+  void connectPinAfter(PinSet *,
+		       Network *) override {}
+  void deletePinBefore(const Pin *,
+                       Network *) override;
   void deleteInstance(const Instance *inst,
                       const Network *network);
 
@@ -443,14 +443,14 @@ public:
                 bool own_pts,
                 const Network *network);
   ExceptionFrom *clone(const Network *network);
-  virtual bool isFrom() const { return true; }
+  bool isFrom() const override { return true; }
   bool intersectsPts(ExceptionFrom *from,
                      const Network *network) const;
-  virtual int typePriority() const { return 0; }
+  int typePriority() const override { return 0; }
 
 protected:
-  virtual const char *cmdKeyword() const;
-  virtual void findHash(const Network *network);
+  const char *cmdKeyword() const override;
+  void findHash(const Network *network) override;
 };
 
 class ExceptionTo : public ExceptionFromTo
@@ -466,12 +466,12 @@ public:
               bool own_pts,
               const Network *network);
   ExceptionTo *clone(const Network *network);
-  virtual bool isTo() const { return true; }
-  const char *asString(const Network *network) const;
+  bool isTo() const override { return true; }
+  const char *asString(const Network *network) const override;
   const RiseFallBoth *endTransition() { return end_rf_; }
   bool intersectsPts(ExceptionTo *to,
                      const Network *network) const;
-  virtual int typePriority() const { return 1; }
+  int typePriority() const override { return 1; }
   bool matches(const Pin *pin,
                const ClockEdge *clk_edge, 
                const RiseFall *end_rf,
@@ -486,8 +486,8 @@ public:
                      const ClockEdge *clk_edge,
                      const RiseFall *end_rf,
                      const Network *network) const;
-  virtual int compare(ExceptionPt *pt,
-                      const Network *network) const;
+  int compare(ExceptionPt *pt,
+              const Network *network) const override;
 
 protected:
   bool matches(const Pin *pin,
@@ -495,7 +495,7 @@ protected:
                const RiseFall *end_rf,
                bool inst_matches_reg_clk_pin,
                const Network *network) const;
-  virtual const char *cmdKeyword() const;
+  const char *cmdKeyword() const override;
 
   // -rise|-fall endpoint transition.
   const RiseFallBoth *end_rf_;
@@ -512,48 +512,48 @@ public:
                 const Network *network);
   ~ExceptionThru();
   ExceptionThru *clone(const Network *network);
-  virtual const char *asString(const Network *network) const;
-  virtual bool isThru() const { return true; }
-  PinSet *pins() { return pins_; }
-  EdgePinsSet *edges() { return edges_; }
-  NetSet *nets() { return nets_; }
-  InstanceSet *instances() { return insts_; }
-  virtual ClockSet *clks() { return nullptr; }
+  const char *asString(const Network *network) const override;
+  bool isThru() const override { return true; }
+  PinSet *pins() override { return pins_; }
+  EdgePinsSet *edges() override { return edges_; }
+  NetSet *nets() override { return nets_; }
+  InstanceSet *instances() override { return insts_; }
+  ClockSet *clks() override { return nullptr; }
   bool hasObjects() const;
   void deleteObjects(ExceptionThru *pt,
                      const Network *network);
-  virtual PinSet allPins(const Network *network);
+  PinSet allPins(const Network *network) override;
   bool matches(const Pin *from_pin,
                const Pin *to_pin,
                const RiseFall *to_rf,
                const Network *network);
   bool equal(ExceptionThru *thru) const;
-  virtual int compare(ExceptionPt *pt,
-                      const Network *network) const;
-  virtual void mergeInto(ExceptionPt *pt,
-                         const Network *network);
+  int compare(ExceptionPt *pt,
+              const Network *network) const override;
+  void mergeInto(ExceptionPt *pt,
+                 const Network *network) override;
   bool intersectsPts(ExceptionThru *thru,
                      const Network *network) const;
-  virtual int typePriority() const { return 2; }
-  virtual size_t objectCount() const;
-  virtual void connectPinAfter(PinSet *drvrs,
-			       Network *network);
-  virtual void deletePinBefore(const Pin *pin,
-                               Network *network);
+  int typePriority() const override { return 2; }
+  size_t objectCount() const override;
+  void connectPinAfter(PinSet *drvrs,
+		       Network *network) override;
+  void deletePinBefore(const Pin *pin,
+                       Network *network) override;
   void deleteInstance(const Instance *inst,
                       const Network *network);
 
 protected:
   void findHash(const Network *network);
-  virtual void addPin(const Pin *pin,
-                      const Network *network);
-  virtual void addEdge(const EdgePins &edge,
-                       const Network *network);
-  virtual void addNet(const Net *net,
-                      const Network *network);
-  virtual void addInstance(const Instance *inst,
-                           const Network *network);
-  virtual void addClock(Clock *) {}
+  void addPin(const Pin *pin,
+              const Network *network) override;
+  void addEdge(const EdgePins &edge,
+               const Network *network) override;
+  void addNet(const Net *net,
+              const Network *network) override;
+  void addInstance(const Instance *inst,
+                   const Network *network) override;
+  void addClock(Clock *) override {}
   void deletePin(const Pin *pin,
                  const Network *network);
   void deleteEdge(const EdgePins &edge);

include/sta/FuncExpr.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/LibertyClass.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/LibertyWriter.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/Mode.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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
@@ -520,10 +520,6 @@ public:
   virtual Pin *connect(Instance *inst,
                        LibertyPort *port,
                        Net *net) = 0;
-  // makePin/connectPin replaced by connect.
-  // deprecated 2018-09-28
-  virtual void connectPin(Pin *pin,
-                          Net *net) __attribute__ ((deprecated));
   // Disconnect pin from net.
   virtual void disconnectPin(Pin *pin) = 0;
   virtual void deletePin(Pin *pin) = 0;

include/sta/NetworkClass.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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/ParasiticsClass.hh

@@ -1,5 +1,5 @@
 // OpenSTA, Static Timing Analyzer
-// Copyright (c) 2025, Parallax Software, Inc.
+// Copyright (c) 2026, 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