odb: fix naming in dbBlock.cpp, dbInst.cpp, tmg_conn_s.cpp

Signed-off-by: Matt Liberty <[email protected]>

Author: maliberty

src/odb/src/db/dbBlock.cpp

@@ -137,20 +137,20 @@ namespace odb {
 
 struct OldTransform
 {
-  int _orient;
-  int _originX;
-  int _originY;
-  int _sizeX;
-  int _sizeY;
+  int orient;
+  int originX;
+  int originY;
+  int sizeX;
+  int sizeY;
 };
 
 dbIStream& operator>>(dbIStream& stream, OldTransform& t)
 {
-  stream >> t._orient;
-  stream >> t._originX;
-  stream >> t._originY;
-  stream >> t._sizeX;
-  stream >> t._sizeY;
+  stream >> t.orient;
+  stream >> t.originX;
+  stream >> t.originY;
+  stream >> t.sizeX;
+  stream >> t.sizeY;
   return stream;
 }
 

src/odb/src/db/dbInst.cpp

@@ -58,15 +58,15 @@ class sortMTerm
 
 class sortITerm
 {
-  _dbBlock* _block;
+  _dbBlock* block_;
 
  public:
-  sortITerm(_dbBlock* block) { _block = block; }
+  sortITerm(_dbBlock* block) { block_ = block; }
 
   bool operator()(uint it1, uint it2)
   {
-    _dbITerm* iterm1 = _block->iterm_tbl_->getPtr(it1);
-    _dbITerm* iterm2 = _block->iterm_tbl_->getPtr(it2);
+    _dbITerm* iterm1 = block_->iterm_tbl_->getPtr(it1);
+    _dbITerm* iterm2 = block_->iterm_tbl_->getPtr(it2);
     return iterm1->flags_.mterm_idx < iterm2->flags_.mterm_idx;
   }
 };

src/odb/src/db/tmg_conn_s.cpp

@@ -85,19 +85,19 @@ class tmg_conn_search::Impl
 
   // Use deque so that emplace_back doesn't move prior elements so pointer
   // into these structures are safe.
-  std::deque<tcs_shape> _shapes;
-  std::deque<tcs_level> _levels;
-  std::array<tcs_level*, 32> _root_for_level;
+  std::deque<tcs_shape> shapes_;
+  std::deque<tcs_level> levels_;
+  std::array<tcs_level*, 32> root_for_level_;
 
   // Used during searching
-  Rect _search_box;
-  int _search_via{0};
-  tcs_level* _search_bin{nullptr};
-  tcs_shape* _search_shape{nullptr};
+  Rect search_box_;
+  int search_via_{0};
+  tcs_level* search_bin_{nullptr};
+  tcs_shape* search_shape_{nullptr};
 
   // Sorting happens after all the shapes have been added and the
   // first searchStart happens
-  bool _sorted{false};
+  bool sorted_{false};
 
   static constexpr int sort_threshold = 1024;
 };
@@ -109,27 +109,27 @@ tmg_conn_search::Impl::Impl()
 
 void tmg_conn_search::Impl::clear()
 {
-  _shapes.clear();
-  _levels.clear();
-  for (tcs_level*& level : _root_for_level) {
-    level = &_levels.emplace_back();
+  shapes_.clear();
+  levels_.clear();
+  for (tcs_level*& level : root_for_level_) {
+    level = &levels_.emplace_back();
     level->reset();
   }
-  _sorted = false;
+  sorted_ = false;
 }
 
 void tmg_conn_search::Impl::addShape(const int level,
                                      const Rect& bounds,
                                      const int is_via,
                                      const int id)
 {
-  tcs_shape* shape = &_shapes.emplace_back();
+  tcs_shape* shape = &shapes_.emplace_back();
   shape->level = level;
   shape->bounds = bounds;
   shape->is_via = is_via;
   shape->id = id;
   shape->next = nullptr;
-  tcs_level* slev = _root_for_level.at(level);
+  tcs_level* slev = root_for_level_.at(level);
   if (slev->shape_list == nullptr) {
     slev->shape_list = shape;
     slev->bounds = shape->bounds;
@@ -145,91 +145,91 @@ void tmg_conn_search::Impl::searchStart(const int level,
                                         const Rect& bounds,
                                         const int is_via)
 {
-  if (!_sorted) {
+  if (!sorted_) {
     sort();
   }
-  _search_bin = _root_for_level.at(level);
-  _search_shape = _search_bin->shape_list;
-  _search_box = bounds;
-  _search_via = is_via;
+  search_bin_ = root_for_level_.at(level);
+  search_shape_ = search_bin_->shape_list;
+  search_box_ = bounds;
+  search_via_ = is_via;
 }
 
 bool tmg_conn_search::Impl::searchNext(int* id)
 {
   *id = -1;
-  if (!_search_bin) {
+  if (!search_bin_) {
     return false;
   }
   // this is for speed for ordinary small nets
-  if (_search_via == 1 && !_search_bin->parent && !_search_bin->left
-      && !_search_bin->right) {
-    while (_search_shape) {
-      if (_search_shape->bounds.overlaps(_search_box)) {
-        *id = _search_shape->id;
-        _search_shape = _search_shape->next;
+  if (search_via_ == 1 && !search_bin_->parent && !search_bin_->left
+      && !search_bin_->right) {
+    while (search_shape_) {
+      if (search_shape_->bounds.overlaps(search_box_)) {
+        *id = search_shape_->id;
+        search_shape_ = search_shape_->next;
         return true;
       }
-      _search_shape = _search_shape->next;
+      search_shape_ = search_shape_->next;
     }
     return false;
   }
 
-  while (_search_bin) {
-    if (_search_bin->bounds.intersects(_search_box)) {
-      while (_search_shape) {
-        if (_search_via == 1 || _search_shape->is_via == 1) {
-          if (!_search_shape->bounds.overlaps(_search_box)) {
-            _search_shape = _search_shape->next;
+  while (search_bin_) {
+    if (search_bin_->bounds.intersects(search_box_)) {
+      while (search_shape_) {
+        if (search_via_ == 1 || search_shape_->is_via == 1) {
+          if (!search_shape_->bounds.overlaps(search_box_)) {
+            search_shape_ = search_shape_->next;
             continue;
           }
         } else {
-          if (!_search_shape->bounds.intersects(_search_box)) {
-            _search_shape = _search_shape->next;
+          if (!search_shape_->bounds.intersects(search_box_)) {
+            search_shape_ = search_shape_->next;
             continue;
           }
           // Skip wire segments that are abutting but staggered, eg
           //        |-------
           //   -----|
           //        |-------
           //   ------
-          if (_search_via == 0
-              && (_search_shape->xMin() == _search_box.xMax()
-                  || _search_box.xMin() == _search_shape->xMax())) {
-            if ((_search_shape->yMax() < _search_box.yMax()
-                 && _search_shape->yMin() < _search_box.yMin())
-                || (_search_shape->yMax() > _search_box.yMax()
-                    && _search_shape->yMin() > _search_box.yMin())) {
-              _search_shape = _search_shape->next;
+          if (search_via_ == 0
+              && (search_shape_->xMin() == search_box_.xMax()
+                  || search_box_.xMin() == search_shape_->xMax())) {
+            if ((search_shape_->yMax() < search_box_.yMax()
+                 && search_shape_->yMin() < search_box_.yMin())
+                || (search_shape_->yMax() > search_box_.yMax()
+                    && search_shape_->yMin() > search_box_.yMin())) {
+              search_shape_ = search_shape_->next;
               continue;
             }
-          } else if (_search_via == 0
-                     && (_search_shape->yMin() == _search_box.yMax()
-                         || _search_box.yMin() == _search_shape->yMax())) {
-            if ((_search_shape->xMax() < _search_box.xMax()
-                 && _search_shape->xMin() < _search_box.xMin())
-                || (_search_shape->xMax() > _search_box.xMax()
-                    && _search_shape->xMin() > _search_box.xMin())) {
-              _search_shape = _search_shape->next;
+          } else if (search_via_ == 0
+                     && (search_shape_->yMin() == search_box_.yMax()
+                         || search_box_.yMin() == search_shape_->yMax())) {
+            if ((search_shape_->xMax() < search_box_.xMax()
+                 && search_shape_->xMin() < search_box_.xMin())
+                || (search_shape_->xMax() > search_box_.xMax()
+                    && search_shape_->xMin() > search_box_.xMin())) {
+              search_shape_ = search_shape_->next;
               continue;
             }
           }
         }
-        *id = _search_shape->id;
-        _search_shape = _search_shape->next;
+        *id = search_shape_->id;
+        search_shape_ = search_shape_->next;
         return true;
       }
     }
-    if (_search_bin->left) {
-      _search_bin = _search_bin->left;
-      _search_shape = _search_bin->shape_list;
+    if (search_bin_->left) {
+      search_bin_ = search_bin_->left;
+      search_shape_ = search_bin_->shape_list;
     } else {
-      while (_search_bin->parent && _search_bin == _search_bin->parent->right) {
-        _search_bin = _search_bin->parent;
+      while (search_bin_->parent && search_bin_ == search_bin_->parent->right) {
+        search_bin_ = search_bin_->parent;
       }
-      _search_bin = _search_bin->parent;
-      if (_search_bin) {
-        _search_bin = _search_bin->right;
-        _search_shape = _search_bin->shape_list;
+      search_bin_ = search_bin_->parent;
+      if (search_bin_) {
+        search_bin_ = search_bin_->right;
+        search_shape_ = search_bin_->shape_list;
       }
     }
   }
@@ -261,10 +261,10 @@ void tmg_conn_search::Impl::sort_level(tcs_level* bin)
   if (bin->num_shapes < sort_threshold) {
     return;
   }
-  tcs_level* left = &_levels.emplace_back();
+  tcs_level* left = &levels_.emplace_back();
   tcs_level_init(left, bin);  // NOLINT(readability-suspicious-call-argument)
 
-  tcs_level* right = &_levels.emplace_back();
+  tcs_level* right = &levels_.emplace_back();
   tcs_level_init(right, bin);  // NOLINT(readability-suspicious-call-argument)
 
   tcs_shape* shape = bin->shape_list;
@@ -302,8 +302,8 @@ void tmg_conn_search::Impl::sort_level(tcs_level* bin)
 
 void tmg_conn_search::Impl::sort()
 {
-  _sorted = true;
-  for (tcs_level* level : _root_for_level) {
+  sorted_ = true;
+  for (tcs_level* level : root_for_level_) {
     sort_level(level);
   }
 }