odb: fix member naming in dbSBox

maliberty · maliberty · commit 0795da68f767 · 2025-11-29T02:48:08.000Z
Signed-off-by: Matt Liberty &lt;mliberty@precisioninno.com&gt;
diff --git a/src/odb/src/db/dbSBox.cpp b/src/odb/src/db/dbSBox.cpp
@@ -27,23 +27,23 @@ template class dbTable<_dbSBox>;
 
 bool _dbSBox::operator==(const _dbSBox& rhs) const
 {
-  if (_sflags._wire_type != rhs._sflags._wire_type) {
+  if (sflags_.wire_type != rhs.sflags_.wire_type) {
     return false;
   }
 
-  if (_sflags._direction != rhs._sflags._direction) {
+  if (sflags_.direction != rhs.sflags_.direction) {
     return false;
   }
 
-  if (_sflags._via_bottom_mask != rhs._sflags._via_bottom_mask) {
+  if (sflags_.via_bottom_mask != rhs.sflags_.via_bottom_mask) {
     return false;
   }
 
-  if (_sflags._via_cut_mask != rhs._sflags._via_cut_mask) {
+  if (sflags_.via_cut_mask != rhs.sflags_.via_cut_mask) {
     return false;
   }
 
-  if (_sflags._via_top_mask != rhs._sflags._via_top_mask) {
+  if (sflags_.via_top_mask != rhs.sflags_.via_top_mask) {
     return false;
   }
 
@@ -56,23 +56,23 @@ bool _dbSBox::operator==(const _dbSBox& rhs) const
 
 int _dbSBox::equal(const _dbSBox& rhs) const
 {
-  if (_sflags._wire_type != rhs._sflags._wire_type) {
+  if (sflags_.wire_type != rhs.sflags_.wire_type) {
     return false;
   }
 
-  if (_sflags._direction != rhs._sflags._direction) {
+  if (sflags_.direction != rhs.sflags_.direction) {
     return false;
   }
 
-  if (_sflags._via_bottom_mask != rhs._sflags._via_bottom_mask) {
+  if (sflags_.via_bottom_mask != rhs.sflags_.via_bottom_mask) {
     return false;
   }
 
-  if (_sflags._via_cut_mask != rhs._sflags._via_cut_mask) {
+  if (sflags_.via_cut_mask != rhs.sflags_.via_cut_mask) {
     return false;
   }
 
-  if (_sflags._via_top_mask != rhs._sflags._via_top_mask) {
+  if (sflags_.via_top_mask != rhs.sflags_.via_top_mask) {
     return false;
   }
 
@@ -81,43 +81,43 @@ int _dbSBox::equal(const _dbSBox& rhs) const
 
 bool _dbSBox::operator<(const _dbSBox& rhs) const
 {
-  if (_sflags._wire_type < rhs._sflags._wire_type) {
+  if (sflags_.wire_type < rhs.sflags_.wire_type) {
     return true;
   }
 
-  if (_sflags._direction < rhs._sflags._direction) {
+  if (sflags_.direction < rhs.sflags_.direction) {
     return true;
   }
 
-  if (_sflags._via_bottom_mask < rhs._sflags._via_bottom_mask) {
+  if (sflags_.via_bottom_mask < rhs.sflags_.via_bottom_mask) {
     return true;
   }
 
-  if (_sflags._via_cut_mask < rhs._sflags._via_cut_mask) {
+  if (sflags_.via_cut_mask < rhs.sflags_.via_cut_mask) {
     return true;
   }
 
-  if (_sflags._via_top_mask < rhs._sflags._via_top_mask) {
+  if (sflags_.via_top_mask < rhs.sflags_.via_top_mask) {
     return true;
   }
 
-  if (_sflags._wire_type > rhs._sflags._wire_type) {
+  if (sflags_.wire_type > rhs.sflags_.wire_type) {
     return false;
   }
 
-  if (_sflags._direction > rhs._sflags._direction) {
+  if (sflags_.direction > rhs.sflags_.direction) {
     return false;
   }
 
-  if (_sflags._via_bottom_mask > rhs._sflags._via_bottom_mask) {
+  if (sflags_.via_bottom_mask > rhs.sflags_.via_bottom_mask) {
     return false;
   }
 
-  if (_sflags._via_cut_mask > rhs._sflags._via_cut_mask) {
+  if (sflags_.via_cut_mask > rhs.sflags_.via_cut_mask) {
     return false;
   }
 
-  if (_sflags._via_top_mask > rhs._sflags._via_top_mask) {
+  if (sflags_.via_top_mask > rhs.sflags_.via_top_mask) {
     return false;
   }
 
@@ -133,13 +133,13 @@ bool _dbSBox::operator<(const _dbSBox& rhs) const
 dbWireShapeType dbSBox::getWireShapeType() const
 {
   const _dbSBox* box = (const _dbSBox*) this;
-  return dbWireShapeType(box->_sflags._wire_type);
+  return dbWireShapeType(box->sflags_.wire_type);
 }
 
 dbSBox::Direction dbSBox::getDirection() const
 {
   const _dbSBox* box = (const _dbSBox*) this;
-  return (dbSBox::Direction) box->_sflags._direction;
+  return (dbSBox::Direction) box->sflags_.direction;
 }
 
 dbSWire* dbSBox::getSWire() const
@@ -156,26 +156,26 @@ Oct dbSBox::getOct() const
 uint dbSBox::getViaBottomLayerMask() const
 {
   const _dbSBox* box = (const _dbSBox*) this;
-  return box->_sflags._via_bottom_mask;
+  return box->sflags_.via_bottom_mask;
 }
 
 uint dbSBox::getViaCutLayerMask() const
 {
   const _dbSBox* box = (const _dbSBox*) this;
-  return box->_sflags._via_cut_mask;
+  return box->sflags_.via_cut_mask;
 }
 
 uint dbSBox::getViaTopLayerMask() const
 {
   const _dbSBox* box = (const _dbSBox*) this;
-  return box->_sflags._via_top_mask;
+  return box->sflags_.via_top_mask;
 }
 
 bool dbSBox::hasViaLayerMasks() const
 {
   const _dbSBox* box = (const _dbSBox*) this;
-  return box->_sflags._via_bottom_mask != 0 || box->_sflags._via_cut_mask != 0
-         || box->_sflags._via_top_mask != 0;
+  return box->sflags_.via_bottom_mask != 0 || box->sflags_.via_cut_mask != 0
+         || box->sflags_.via_top_mask != 0;
 }
 
 void dbSBox::setViaLayerMask(const uint bottom, const uint cut, const uint top)
@@ -185,9 +185,9 @@ void dbSBox::setViaLayerMask(const uint bottom, const uint cut, const uint top)
   box->checkMask(cut);
   box->checkMask(top);
 
-  box->_sflags._via_bottom_mask = bottom;
-  box->_sflags._via_cut_mask = cut;
-  box->_sflags._via_top_mask = top;
+  box->sflags_.via_bottom_mask = bottom;
+  box->sflags_.via_cut_mask = cut;
+  box->sflags_.via_top_mask = top;
 }
 
 dbSBox* dbSBox::create(dbSWire* wire_,
@@ -248,8 +248,8 @@ dbSBox* dbSBox::create(dbSWire* wire_,
     block->add_rect(box->shape_.rect);
   }
 
-  box->_sflags._wire_type = type.getValue();
-  box->_sflags._direction = dir;
+  box->sflags_.wire_type = type.getValue();
+  box->sflags_.direction = dir;
 
   wire->addSBox(box);
 
@@ -281,7 +281,7 @@ dbSBox* dbSBox::create(dbSWire* wire_,
   box->flags_.is_block_via = 1;
   box->flags_.via_id = via->getOID();
   box->flags_.octilinear = false;
-  box->_sflags._wire_type = type.getValue();
+  box->sflags_.wire_type = type.getValue();
 
   wire->addSBox(box);
 
@@ -315,7 +315,7 @@ dbSBox* dbSBox::create(dbSWire* wire_,
   box->flags_.is_tech_via = 1;
   box->flags_.via_id = via->getOID();
   box->flags_.octilinear = false;
-  box->_sflags._wire_type = type.getValue();
+  box->sflags_.wire_type = type.getValue();
 
   wire->addSBox(box);
 
@@ -407,32 +407,32 @@ std::vector<dbSBox*> dbSBox::smashVia()
 }
 
 _dbSBox::_dbSBox(_dbDatabase* db, const _dbSBox& b)
-    : _dbBox(db, b), _sflags(b._sflags)
+    : _dbBox(db, b), sflags_(b.sflags_)
 {
 }
 
 _dbSBox::_dbSBox(_dbDatabase* db) : _dbBox(db)
 {
-  _sflags._wire_type = dbWireShapeType::COREWIRE;
-  _sflags._direction = 0;
-  _sflags._via_bottom_mask = 0;
-  _sflags._via_cut_mask = 0;
-  _sflags._via_top_mask = 0;
-  _sflags._spare_bits = 0;
+  sflags_.wire_type = dbWireShapeType::COREWIRE;
+  sflags_.direction = 0;
+  sflags_.via_bottom_mask = 0;
+  sflags_.via_cut_mask = 0;
+  sflags_.via_top_mask = 0;
+  sflags_.spare_bits = 0;
 }
 
 dbOStream& operator<<(dbOStream& stream, const _dbSBox& box)
 {
   stream << (_dbBox&) box;
-  uint* bit_field = (uint*) &box._sflags;
+  uint* bit_field = (uint*) &box.sflags_;
   stream << *bit_field;
   return stream;
 }
 
 dbIStream& operator>>(dbIStream& stream, _dbSBox& box)
 {
   stream >> (_dbBox&) box;
-  uint* bit_field = (uint*) &box._sflags;
+  uint* bit_field = (uint*) &box.sflags_;
   stream >> *bit_field;
   return stream;
 }
diff --git a/src/odb/src/db/dbSBox.h b/src/odb/src/db/dbSBox.h
@@ -18,13 +18,13 @@ class dbOStream;
 
 struct _dbSBoxFlags
 {
-  dbWireShapeType::Value _wire_type : 6;
-  uint _direction : 2;  // 0 = undefiend, 1 = horizontal, 2 = vertical, 3 =
-                        // octilinear
-  uint _via_bottom_mask : 2;
-  uint _via_cut_mask : 2;
-  uint _via_top_mask : 2;
-  uint _spare_bits : 18;
+  dbWireShapeType::Value wire_type : 6;
+  uint direction : 2;  // 0 = undefiend, 1 = horizontal, 2 = vertical, 3 =
+                       // octilinear
+  uint via_bottom_mask : 2;
+  uint via_cut_mask : 2;
+  uint via_top_mask : 2;
+  uint spare_bits : 18;
 };
 
 class _dbSBox : public _dbBox
@@ -39,7 +39,7 @@ class _dbSBox : public _dbBox
   int equal(const _dbSBox& rhs) const;
 
   // PERSISTANT-MEMBERS
-  _dbSBoxFlags _sflags;
+  _dbSBoxFlags sflags_;
 };
 
 dbOStream& operator<<(dbOStream& stream, const _dbSBox& box);

Original file line number	Diff line number	Diff line change
`@@ -27,23 +27,23 @@ template class dbTable<_dbSBox>;`
`27`	`27`
`28`	`28`	`bool _dbSBox::operator==(const _dbSBox& rhs) const`
`29`	`29`	`{`
`30`		`- if (_sflags._wire_type != rhs._sflags._wire_type) {`
	`30`	`+ if (sflags_.wire_type != rhs.sflags_.wire_type) {`
`31`	`31`	`return false;`
`32`	`32`	`}`
`33`	`33`
`34`		`- if (_sflags._direction != rhs._sflags._direction) {`
	`34`	`+ if (sflags_.direction != rhs.sflags_.direction) {`
`35`	`35`	`return false;`
`36`	`36`	`}`
`37`	`37`
`38`		`- if (_sflags._via_bottom_mask != rhs._sflags._via_bottom_mask) {`
	`38`	`+ if (sflags_.via_bottom_mask != rhs.sflags_.via_bottom_mask) {`
`39`	`39`	`return false;`
`40`	`40`	`}`
`41`	`41`
`42`		`- if (_sflags._via_cut_mask != rhs._sflags._via_cut_mask) {`
	`42`	`+ if (sflags_.via_cut_mask != rhs.sflags_.via_cut_mask) {`
`43`	`43`	`return false;`
`44`	`44`	`}`
`45`	`45`
`46`		`- if (_sflags._via_top_mask != rhs._sflags._via_top_mask) {`
	`46`	`+ if (sflags_.via_top_mask != rhs.sflags_.via_top_mask) {`
`47`	`47`	`return false;`
`48`	`48`	`}`
`49`	`49`
`@@ -56,23 +56,23 @@ bool _dbSBox::operator==(const _dbSBox& rhs) const`
`56`	`56`
`57`	`57`	`int _dbSBox::equal(const _dbSBox& rhs) const`
`58`	`58`	`{`
`59`		`- if (_sflags._wire_type != rhs._sflags._wire_type) {`
	`59`	`+ if (sflags_.wire_type != rhs.sflags_.wire_type) {`
`60`	`60`	`return false;`
`61`	`61`	`}`
`62`	`62`
`63`		`- if (_sflags._direction != rhs._sflags._direction) {`
	`63`	`+ if (sflags_.direction != rhs.sflags_.direction) {`
`64`	`64`	`return false;`
`65`	`65`	`}`
`66`	`66`
`67`		`- if (_sflags._via_bottom_mask != rhs._sflags._via_bottom_mask) {`
	`67`	`+ if (sflags_.via_bottom_mask != rhs.sflags_.via_bottom_mask) {`
`68`	`68`	`return false;`
`69`	`69`	`}`
`70`	`70`
`71`		`- if (_sflags._via_cut_mask != rhs._sflags._via_cut_mask) {`
	`71`	`+ if (sflags_.via_cut_mask != rhs.sflags_.via_cut_mask) {`
`72`	`72`	`return false;`
`73`	`73`	`}`
`74`	`74`
`75`		`- if (_sflags._via_top_mask != rhs._sflags._via_top_mask) {`
	`75`	`+ if (sflags_.via_top_mask != rhs.sflags_.via_top_mask) {`
`76`	`76`	`return false;`
`77`	`77`	`}`
`78`	`78`
`@@ -81,43 +81,43 @@ int _dbSBox::equal(const _dbSBox& rhs) const`
`81`	`81`
`82`	`82`	`bool _dbSBox::operator<(const _dbSBox& rhs) const`
`83`	`83`	`{`
`84`		`- if (_sflags._wire_type < rhs._sflags._wire_type) {`
	`84`	`+ if (sflags_.wire_type < rhs.sflags_.wire_type) {`
`85`	`85`	`return true;`
`86`	`86`	`}`
`87`	`87`
`88`		`- if (_sflags._direction < rhs._sflags._direction) {`
	`88`	`+ if (sflags_.direction < rhs.sflags_.direction) {`
`89`	`89`	`return true;`
`90`	`90`	`}`
`91`	`91`
`92`		`- if (_sflags._via_bottom_mask < rhs._sflags._via_bottom_mask) {`
	`92`	`+ if (sflags_.via_bottom_mask < rhs.sflags_.via_bottom_mask) {`
`93`	`93`	`return true;`
`94`	`94`	`}`
`95`	`95`
`96`		`- if (_sflags._via_cut_mask < rhs._sflags._via_cut_mask) {`
	`96`	`+ if (sflags_.via_cut_mask < rhs.sflags_.via_cut_mask) {`
`97`	`97`	`return true;`
`98`	`98`	`}`
`99`	`99`
`100`		`- if (_sflags._via_top_mask < rhs._sflags._via_top_mask) {`
	`100`	`+ if (sflags_.via_top_mask < rhs.sflags_.via_top_mask) {`
`101`	`101`	`return true;`
`102`	`102`	`}`
`103`	`103`
`104`		`- if (_sflags._wire_type > rhs._sflags._wire_type) {`
	`104`	`+ if (sflags_.wire_type > rhs.sflags_.wire_type) {`
`105`	`105`	`return false;`
`106`	`106`	`}`
`107`	`107`
`108`		`- if (_sflags._direction > rhs._sflags._direction) {`
	`108`	`+ if (sflags_.direction > rhs.sflags_.direction) {`
`109`	`109`	`return false;`
`110`	`110`	`}`
`111`	`111`
`112`		`- if (_sflags._via_bottom_mask > rhs._sflags._via_bottom_mask) {`
	`112`	`+ if (sflags_.via_bottom_mask > rhs.sflags_.via_bottom_mask) {`
`113`	`113`	`return false;`
`114`	`114`	`}`
`115`	`115`
`116`		`- if (_sflags._via_cut_mask > rhs._sflags._via_cut_mask) {`
	`116`	`+ if (sflags_.via_cut_mask > rhs.sflags_.via_cut_mask) {`
`117`	`117`	`return false;`
`118`	`118`	`}`
`119`	`119`
`120`		`- if (_sflags._via_top_mask > rhs._sflags._via_top_mask) {`
	`120`	`+ if (sflags_.via_top_mask > rhs.sflags_.via_top_mask) {`
`121`	`121`	`return false;`
`122`	`122`	`}`
`123`	`123`
`@@ -133,13 +133,13 @@ bool _dbSBox::operator<(const _dbSBox& rhs) const`
`133`	`133`	`dbWireShapeType dbSBox::getWireShapeType() const`
`134`	`134`	`{`
`135`	`135`	`const _dbSBox* box = (const _dbSBox*) this;`
`136`		`- return dbWireShapeType(box->_sflags._wire_type);`
	`136`	`+ return dbWireShapeType(box->sflags_.wire_type);`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`dbSBox::Direction dbSBox::getDirection() const`
`140`	`140`	`{`
`141`	`141`	`const _dbSBox* box = (const _dbSBox*) this;`
`142`		`- return (dbSBox::Direction) box->_sflags._direction;`
	`142`	`+ return (dbSBox::Direction) box->sflags_.direction;`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`dbSWire* dbSBox::getSWire() const`
`@@ -156,26 +156,26 @@ Oct dbSBox::getOct() const`
`156`	`156`	`uint dbSBox::getViaBottomLayerMask() const`
`157`	`157`	`{`
`158`	`158`	`const _dbSBox* box = (const _dbSBox*) this;`
`159`		`- return box->_sflags._via_bottom_mask;`
	`159`	`+ return box->sflags_.via_bottom_mask;`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`uint dbSBox::getViaCutLayerMask() const`
`163`	`163`	`{`
`164`	`164`	`const _dbSBox* box = (const _dbSBox*) this;`
`165`		`- return box->_sflags._via_cut_mask;`
	`165`	`+ return box->sflags_.via_cut_mask;`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`uint dbSBox::getViaTopLayerMask() const`
`169`	`169`	`{`
`170`	`170`	`const _dbSBox* box = (const _dbSBox*) this;`
`171`		`- return box->_sflags._via_top_mask;`
	`171`	`+ return box->sflags_.via_top_mask;`
`172`	`172`	`}`
`173`	`173`
`174`	`174`	`bool dbSBox::hasViaLayerMasks() const`
`175`	`175`	`{`
`176`	`176`	`const _dbSBox* box = (const _dbSBox*) this;`
`177`		`- return box->_sflags._via_bottom_mask != 0 \|\| box->_sflags._via_cut_mask != 0`
`178`		`- \|\| box->_sflags._via_top_mask != 0;`
	`177`	`+ return box->sflags_.via_bottom_mask != 0 \|\| box->sflags_.via_cut_mask != 0`
	`178`	`+ \|\| box->sflags_.via_top_mask != 0;`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`void dbSBox::setViaLayerMask(const uint bottom, const uint cut, const uint top)`
`@@ -185,9 +185,9 @@ void dbSBox::setViaLayerMask(const uint bottom, const uint cut, const uint top)`
`185`	`185`	`box->checkMask(cut);`
`186`	`186`	`box->checkMask(top);`
`187`	`187`
`188`		`- box->_sflags._via_bottom_mask = bottom;`
`189`		`- box->_sflags._via_cut_mask = cut;`
`190`		`- box->_sflags._via_top_mask = top;`
	`188`	`+ box->sflags_.via_bottom_mask = bottom;`
	`189`	`+ box->sflags_.via_cut_mask = cut;`
	`190`	`+ box->sflags_.via_top_mask = top;`
`191`	`191`	`}`
`192`	`192`
`193`	`193`	`dbSBox* dbSBox::create(dbSWire* wire_,`
`@@ -248,8 +248,8 @@ dbSBox* dbSBox::create(dbSWire* wire_,`
`248`	`248`	`block->add_rect(box->shape_.rect);`
`249`	`249`	`}`
`250`	`250`
`251`		`- box->_sflags._wire_type = type.getValue();`
`252`		`- box->_sflags._direction = dir;`
	`251`	`+ box->sflags_.wire_type = type.getValue();`
	`252`	`+ box->sflags_.direction = dir;`
`253`	`253`
`254`	`254`	`wire->addSBox(box);`
`255`	`255`
`@@ -281,7 +281,7 @@ dbSBox* dbSBox::create(dbSWire* wire_,`
`281`	`281`	`box->flags_.is_block_via = 1;`
`282`	`282`	`box->flags_.via_id = via->getOID();`
`283`	`283`	`box->flags_.octilinear = false;`
`284`		`- box->_sflags._wire_type = type.getValue();`
	`284`	`+ box->sflags_.wire_type = type.getValue();`
`285`	`285`
`286`	`286`	`wire->addSBox(box);`
`287`	`287`
`@@ -315,7 +315,7 @@ dbSBox* dbSBox::create(dbSWire* wire_,`
`315`	`315`	`box->flags_.is_tech_via = 1;`
`316`	`316`	`box->flags_.via_id = via->getOID();`
`317`	`317`	`box->flags_.octilinear = false;`
`318`		`- box->_sflags._wire_type = type.getValue();`
	`318`	`+ box->sflags_.wire_type = type.getValue();`
`319`	`319`
`320`	`320`	`wire->addSBox(box);`
`321`	`321`
`@@ -407,32 +407,32 @@ std::vector<dbSBox*> dbSBox::smashVia()`
`407`	`407`	`}`
`408`	`408`
`409`	`409`	`_dbSBox::_dbSBox(_dbDatabase* db, const _dbSBox& b)`
`410`		`- : _dbBox(db, b), _sflags(b._sflags)`
	`410`	`+ : _dbBox(db, b), sflags_(b.sflags_)`
`411`	`411`	`{`
`412`	`412`	`}`
`413`	`413`
`414`	`414`	`_dbSBox::_dbSBox(_dbDatabase* db) : _dbBox(db)`
`415`	`415`	`{`
`416`		`- _sflags._wire_type = dbWireShapeType::COREWIRE;`
`417`		`- _sflags._direction = 0;`
`418`		`- _sflags._via_bottom_mask = 0;`
`419`		`- _sflags._via_cut_mask = 0;`
`420`		`- _sflags._via_top_mask = 0;`
`421`		`- _sflags._spare_bits = 0;`
	`416`	`+ sflags_.wire_type = dbWireShapeType::COREWIRE;`
	`417`	`+ sflags_.direction = 0;`
	`418`	`+ sflags_.via_bottom_mask = 0;`
	`419`	`+ sflags_.via_cut_mask = 0;`
	`420`	`+ sflags_.via_top_mask = 0;`
	`421`	`+ sflags_.spare_bits = 0;`
`422`	`422`	`}`
`423`	`423`
`424`	`424`	`dbOStream& operator<<(dbOStream& stream, const _dbSBox& box)`
`425`	`425`	`{`
`426`	`426`	`stream << (_dbBox&) box;`
`427`		`- uint* bit_field = (uint*) &box._sflags;`
	`427`	`+ uint* bit_field = (uint*) &box.sflags_;`
`428`	`428`	`stream << *bit_field;`
`429`	`429`	`return stream;`
`430`	`430`	`}`
`431`	`431`
`432`	`432`	`dbIStream& operator>>(dbIStream& stream, _dbSBox& box)`
`433`	`433`	`{`
`434`	`434`	`stream >> (_dbBox&) box;`
`435`		`- uint* bit_field = (uint*) &box._sflags;`
	`435`	`+ uint* bit_field = (uint*) &box.sflags_;`
`436`	`436`	`stream >> *bit_field;`
`437`	`437`	`return stream;`
`438`	`438`	`}`