Odb: split LefDefParser namespace into LefParser and DefParser

src/odb/include/odb/lefin.h

@@ -39,7 +39,7 @@
 #include "odb.h"
 #include "utl/Logger.h"
 
-namespace LefDefParser {
+namespace LefParser {
 class lefiArray;
 struct lefiNoiseMargin;
 class lefiNoiseTable;
@@ -64,7 +64,7 @@ class lefiMaxStackVia;
 class lefiObstruction;
 class lefiGeometries;
 struct lefiGeomPolygon;
-}  // namespace LefDefParser
+}  // namespace LefParser
 
 namespace odb {
 
@@ -77,7 +77,7 @@ class dbDatabase;
 class dbTechLayer;
 class dbSite;
 
-using namespace LefDefParser;
+using namespace LefParser;
 
 class lefin
 {

src/odb/src/def/cdef/xdefiAssertion.cpp

@@ -39,97 +39,97 @@
 // Wrappers definitions.
 int defiAssertion_isAssertion(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->isAssertion();
+  return ((DefParser::defiAssertion*) obj)->isAssertion();
 }
 
 int defiAssertion_isConstraint(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->isConstraint();
+  return ((DefParser::defiAssertion*) obj)->isConstraint();
 }
 
 int defiAssertion_isWiredlogic(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->isWiredlogic();
+  return ((DefParser::defiAssertion*) obj)->isWiredlogic();
 }
 
 int defiAssertion_isDelay(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->isDelay();
+  return ((DefParser::defiAssertion*) obj)->isDelay();
 }
 
 int defiAssertion_isSum(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->isSum();
+  return ((DefParser::defiAssertion*) obj)->isSum();
 }
 
 int defiAssertion_isDiff(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->isDiff();
+  return ((DefParser::defiAssertion*) obj)->isDiff();
 }
 
 int defiAssertion_hasRiseMin(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->hasRiseMin();
+  return ((DefParser::defiAssertion*) obj)->hasRiseMin();
 }
 
 int defiAssertion_hasRiseMax(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->hasRiseMax();
+  return ((DefParser::defiAssertion*) obj)->hasRiseMax();
 }
 
 int defiAssertion_hasFallMin(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->hasFallMin();
+  return ((DefParser::defiAssertion*) obj)->hasFallMin();
 }
 
 int defiAssertion_hasFallMax(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->hasFallMax();
+  return ((DefParser::defiAssertion*) obj)->hasFallMax();
 }
 
 double defiAssertion_riseMin(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->riseMin();
+  return ((DefParser::defiAssertion*) obj)->riseMin();
 }
 
 double defiAssertion_riseMax(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->riseMax();
+  return ((DefParser::defiAssertion*) obj)->riseMax();
 }
 
 double defiAssertion_fallMin(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->fallMin();
+  return ((DefParser::defiAssertion*) obj)->fallMin();
 }
 
 double defiAssertion_fallMax(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->fallMax();
+  return ((DefParser::defiAssertion*) obj)->fallMax();
 }
 
 const char* defiAssertion_netName(const ::defiAssertion* obj)
 {
-  return ((const LefDefParser::defiAssertion*) obj)->netName();
+  return ((const DefParser::defiAssertion*) obj)->netName();
 }
 
 double defiAssertion_distance(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->distance();
+  return ((DefParser::defiAssertion*) obj)->distance();
 }
 
 int defiAssertion_numItems(const ::defiAssertion* obj)
 {
-  return ((LefDefParser::defiAssertion*) obj)->numItems();
+  return ((DefParser::defiAssertion*) obj)->numItems();
 }
 
 int defiAssertion_isPath(const ::defiAssertion* obj, int index)
 {
-  return ((LefDefParser::defiAssertion*) obj)->isPath(index);
+  return ((DefParser::defiAssertion*) obj)->isPath(index);
 }
 
 int defiAssertion_isNet(const ::defiAssertion* obj, int index)
 {
-  return ((LefDefParser::defiAssertion*) obj)->isNet(index);
+  return ((DefParser::defiAssertion*) obj)->isNet(index);
 }
 
 void defiAssertion_path(const ::defiAssertion* obj,
@@ -139,16 +139,16 @@ void defiAssertion_path(const ::defiAssertion* obj,
                         char** toInst,
                         char** toPin)
 {
-  ((LefDefParser::defiAssertion*) obj)
+  ((DefParser::defiAssertion*) obj)
       ->path(index, fromInst, fromPin, toInst, toPin);
 }
 
 void defiAssertion_net(const ::defiAssertion* obj, int index, char** netName)
 {
-  ((LefDefParser::defiAssertion*) obj)->net(index, netName);
+  ((DefParser::defiAssertion*) obj)->net(index, netName);
 }
 
 void defiAssertion_print(const ::defiAssertion* obj, FILE* f)
 {
-  ((LefDefParser::defiAssertion*) obj)->print(f);
+  ((DefParser::defiAssertion*) obj)->print(f);
 }

src/odb/src/def/cdef/xdefiBlockage.cpp

@@ -38,144 +38,144 @@
 
 union udefiPoints
 {
-  LefDefParser::defiPoints cpp;
+  DefParser::defiPoints cpp;
   ::defiPoints c;
 };
 
 // Wrappers definitions.
 int defiBlockage_hasLayer(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->hasLayer();
+  return ((DefParser::defiBlockage*) obj)->hasLayer();
 }
 
 int defiBlockage_hasPlacement(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->hasPlacement();
+  return ((DefParser::defiBlockage*) obj)->hasPlacement();
 }
 
 int defiBlockage_hasComponent(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->hasComponent();
+  return ((DefParser::defiBlockage*) obj)->hasComponent();
 }
 
 int defiBlockage_hasSlots(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->hasSlots();
+  return ((DefParser::defiBlockage*) obj)->hasSlots();
 }
 
 int defiBlockage_hasFills(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->hasFills();
+  return ((DefParser::defiBlockage*) obj)->hasFills();
 }
 
 int defiBlockage_hasPushdown(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->hasPushdown();
+  return ((DefParser::defiBlockage*) obj)->hasPushdown();
 }
 
 int defiBlockage_hasExceptpgnet(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->hasExceptpgnet();
+  return ((DefParser::defiBlockage*) obj)->hasExceptpgnet();
 }
 
 int defiBlockage_hasSoft(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->hasSoft();
+  return ((DefParser::defiBlockage*) obj)->hasSoft();
 }
 
 int defiBlockage_hasPartial(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->hasPartial();
+  return ((DefParser::defiBlockage*) obj)->hasPartial();
 }
 
 int defiBlockage_hasSpacing(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->hasSpacing();
+  return ((DefParser::defiBlockage*) obj)->hasSpacing();
 }
 
 int defiBlockage_hasDesignRuleWidth(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->hasDesignRuleWidth();
+  return ((DefParser::defiBlockage*) obj)->hasDesignRuleWidth();
 }
 
 int defiBlockage_hasMask(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->hasMask();
+  return ((DefParser::defiBlockage*) obj)->hasMask();
 }
 
 int defiBlockage_mask(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->mask();
+  return ((DefParser::defiBlockage*) obj)->mask();
 }
 
 int defiBlockage_minSpacing(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->minSpacing();
+  return ((DefParser::defiBlockage*) obj)->minSpacing();
 }
 
 int defiBlockage_designRuleWidth(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->designRuleWidth();
+  return ((DefParser::defiBlockage*) obj)->designRuleWidth();
 }
 
 double defiBlockage_placementMaxDensity(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->placementMaxDensity();
+  return ((DefParser::defiBlockage*) obj)->placementMaxDensity();
 }
 
 const char* defiBlockage_layerName(const ::defiBlockage* obj)
 {
-  return ((const LefDefParser::defiBlockage*) obj)->layerName();
+  return ((const DefParser::defiBlockage*) obj)->layerName();
 }
 
 const char* defiBlockage_layerComponentName(const ::defiBlockage* obj)
 {
-  return ((const LefDefParser::defiBlockage*) obj)->layerComponentName();
+  return ((const DefParser::defiBlockage*) obj)->layerComponentName();
 }
 
 const char* defiBlockage_placementComponentName(const ::defiBlockage* obj)
 {
-  return ((const LefDefParser::defiBlockage*) obj)->placementComponentName();
+  return ((const DefParser::defiBlockage*) obj)->placementComponentName();
 }
 
 int defiBlockage_numRectangles(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->numRectangles();
+  return ((DefParser::defiBlockage*) obj)->numRectangles();
 }
 
 int defiBlockage_xl(const ::defiBlockage* obj, int index)
 {
-  return ((LefDefParser::defiBlockage*) obj)->xl(index);
+  return ((DefParser::defiBlockage*) obj)->xl(index);
 }
 
 int defiBlockage_yl(const ::defiBlockage* obj, int index)
 {
-  return ((LefDefParser::defiBlockage*) obj)->yl(index);
+  return ((DefParser::defiBlockage*) obj)->yl(index);
 }
 
 int defiBlockage_xh(const ::defiBlockage* obj, int index)
 {
-  return ((LefDefParser::defiBlockage*) obj)->xh(index);
+  return ((DefParser::defiBlockage*) obj)->xh(index);
 }
 
 int defiBlockage_yh(const ::defiBlockage* obj, int index)
 {
-  return ((LefDefParser::defiBlockage*) obj)->yh(index);
+  return ((DefParser::defiBlockage*) obj)->yh(index);
 }
 
 int defiBlockage_numPolygons(const ::defiBlockage* obj)
 {
-  return ((LefDefParser::defiBlockage*) obj)->numPolygons();
+  return ((DefParser::defiBlockage*) obj)->numPolygons();
 }
 
 ::defiPoints defiBlockage_getPolygon(const ::defiBlockage* obj, int index)
 {
   udefiPoints tmp;
-  tmp.cpp = ((LefDefParser::defiBlockage*) obj)->getPolygon(index);
+  tmp.cpp = ((DefParser::defiBlockage*) obj)->getPolygon(index);
   return tmp.c;
 }
 
 void defiBlockage_print(const ::defiBlockage* obj, FILE* f)
 {
-  ((LefDefParser::defiBlockage*) obj)->print(f);
+  ((DefParser::defiBlockage*) obj)->print(f);
 }