diff --git a/src/plugins/streamers/lefdef/db_plugin/dbDEFImporter.cc b/src/plugins/streamers/lefdef/db_plugin/dbDEFImporter.cc index 3c047f817..708e29b12 100644 --- a/src/plugins/streamers/lefdef/db_plugin/dbDEFImporter.cc +++ b/src/plugins/streamers/lefdef/db_plugin/dbDEFImporter.cc @@ -543,7 +543,7 @@ DEFImporter::read_single_net (std::string &nondefaultrule, Layout &layout, db::C test (")"); - std::pair dl = open_layer (layout, ln, Routing); + std::pair dl = open_layer (layout, ln, specialnets ? SpecialRouting : Routing); if (dl.first) { db::Point p (x, y); @@ -597,7 +597,7 @@ DEFImporter::read_single_net (std::string &nondefaultrule, Layout &layout, db::C } if (pts.size () > 1) { - std::pair dl = open_layer (layout, ln, Routing); + std::pair dl = open_layer (layout, ln, specialnets ? SpecialRouting : Routing); if (dl.first) { produce_routing_geometry (design, style, dl.second, prop_id, pts, ext, w); } @@ -749,7 +749,7 @@ DEFImporter::read_nets (db::Layout &layout, db::Cell &design, double scale, bool db::Polygon p; read_polygon (p, scale); - std::pair dl = open_layer (layout, ln, Routing); + std::pair dl = open_layer (layout, ln, specialnets ? SpecialRouting : Routing); if (dl.first) { if (prop_id != 0) { design.shapes (dl.second).insert (db::object_with_properties (p, prop_id)); @@ -767,7 +767,7 @@ DEFImporter::read_nets (db::Layout &layout, db::Cell &design, double scale, bool db::Polygon p; read_rect (p, scale); - std::pair dl = open_layer (layout, ln, Routing); + std::pair dl = open_layer (layout, ln, specialnets ? SpecialRouting : Routing); if (dl.first) { if (prop_id != 0) { design.shapes (dl.second).insert (db::object_with_properties (p, prop_id)); diff --git a/src/plugins/streamers/lefdef/db_plugin/dbLEFDEFImporter.cc b/src/plugins/streamers/lefdef/db_plugin/dbLEFDEFImporter.cc index d045b7534..07122526d 100644 --- a/src/plugins/streamers/lefdef/db_plugin/dbLEFDEFImporter.cc +++ b/src/plugins/streamers/lefdef/db_plugin/dbLEFDEFImporter.cc @@ -56,6 +56,9 @@ LEFDEFReaderOptions::LEFDEFReaderOptions () m_produce_pins (true), m_pins_suffix (".PIN"), m_pins_datatype (2), + m_produce_lef_pins (true), + m_lef_pins_suffix (".PIN"), + m_lef_pins_datatype (2), m_produce_obstructions (true), m_obstructions_suffix (".OBS"), m_obstructions_datatype (3), @@ -68,6 +71,9 @@ LEFDEFReaderOptions::LEFDEFReaderOptions () m_produce_routing (true), m_routing_suffix (""), m_routing_datatype (0), + m_produce_special_routing (true), + m_special_routing_suffix (""), + m_special_routing_datatype (0), m_separate_groups (false) { // .. nothing yet .. @@ -96,6 +102,9 @@ LEFDEFReaderOptions::LEFDEFReaderOptions (const LEFDEFReaderOptions &d) m_produce_pins (d.m_produce_pins), m_pins_suffix (d.m_pins_suffix), m_pins_datatype (d.m_pins_datatype), + m_produce_lef_pins (d.m_produce_lef_pins), + m_lef_pins_suffix (d.m_lef_pins_suffix), + m_lef_pins_datatype (d.m_lef_pins_datatype), m_produce_obstructions (d.m_produce_obstructions), m_obstructions_suffix (d.m_obstructions_suffix), m_obstructions_datatype (d.m_obstructions_datatype), @@ -108,6 +117,9 @@ LEFDEFReaderOptions::LEFDEFReaderOptions (const LEFDEFReaderOptions &d) m_produce_routing (d.m_produce_routing), m_routing_suffix (d.m_routing_suffix), m_routing_datatype (d.m_routing_datatype), + m_produce_special_routing (d.m_produce_special_routing), + m_special_routing_suffix (d.m_special_routing_suffix), + m_special_routing_datatype (d.m_special_routing_datatype), m_separate_groups (d.m_separate_groups), m_lef_files (d.m_lef_files) { @@ -216,6 +228,9 @@ LEFDEFReaderState::open_layer (db::Layout &layout, const std::string &n, LayerPu default: produce = mp_tech_comp->produce_routing (); break; + case SpecialRouting: + produce = mp_tech_comp->produce_special_routing (); + break; case ViaGeometry: produce = mp_tech_comp->produce_via_geometry (); break; @@ -225,6 +240,9 @@ LEFDEFReaderState::open_layer (db::Layout &layout, const std::string &n, LayerPu case Pins: produce = mp_tech_comp->produce_pins (); break; + case LEFPins: + produce = mp_tech_comp->produce_lef_pins (); + break; case Obstructions: produce = mp_tech_comp->produce_obstructions (); break; @@ -255,6 +273,11 @@ LEFDEFReaderState::open_layer (db::Layout &layout, const std::string &n, LayerPu canonical_purpose = "NET"; dt += mp_tech_comp->routing_datatype (); break; + case SpecialRouting: + name += mp_tech_comp->special_routing_suffix (); + canonical_purpose = "SPNET"; + dt += mp_tech_comp->special_routing_datatype (); + break; case ViaGeometry: name += mp_tech_comp->via_geometry_suffix (); dt += mp_tech_comp->via_geometry_datatype (); @@ -270,6 +293,11 @@ LEFDEFReaderState::open_layer (db::Layout &layout, const std::string &n, LayerPu dt += mp_tech_comp->pins_datatype (); canonical_purpose = "PIN"; break; + case LEFPins: + name += mp_tech_comp->lef_pins_suffix (); + dt += mp_tech_comp->lef_pins_datatype (); + canonical_purpose = "LEFPIN"; + break; case Obstructions: name += mp_tech_comp->obstructions_suffix (); dt += mp_tech_comp->obstructions_datatype (); @@ -360,6 +388,9 @@ LEFDEFReaderState::finish (db::Layout &layout) default: dt = mp_tech_comp->routing_datatype (); break; + case SpecialRouting: + dt = mp_tech_comp->special_routing_datatype (); + break; case ViaGeometry: dt = mp_tech_comp->via_geometry_datatype (); break; @@ -369,6 +400,9 @@ LEFDEFReaderState::finish (db::Layout &layout) case Pins: dt = mp_tech_comp->pins_datatype (); break; + case LEFPins: + dt = mp_tech_comp->lef_pins_datatype (); + break; case Obstructions: dt = mp_tech_comp->obstructions_datatype (); break; diff --git a/src/plugins/streamers/lefdef/db_plugin/dbLEFDEFImporter.h b/src/plugins/streamers/lefdef/db_plugin/dbLEFDEFImporter.h index 83e84ecb0..6c9adf325 100644 --- a/src/plugins/streamers/lefdef/db_plugin/dbLEFDEFImporter.h +++ b/src/plugins/streamers/lefdef/db_plugin/dbLEFDEFImporter.h @@ -295,6 +295,36 @@ public: m_pins_datatype = s; } + bool produce_lef_pins () const + { + return m_produce_lef_pins; + } + + void set_produce_lef_pins (bool f) + { + m_produce_lef_pins = f; + } + + const std::string &lef_pins_suffix () const + { + return m_lef_pins_suffix; + } + + void set_lef_pins_suffix (const std::string &s) + { + m_lef_pins_suffix = s; + } + + int lef_pins_datatype () const + { + return m_lef_pins_datatype; + } + + void set_lef_pins_datatype (int s) + { + m_lef_pins_datatype = s; + } + bool produce_obstructions () const { return m_produce_obstructions; @@ -415,6 +445,36 @@ public: m_routing_datatype = s; } + bool produce_special_routing () const + { + return m_produce_special_routing; + } + + void set_produce_special_routing (bool f) + { + m_produce_special_routing = f; + } + + const std::string &special_routing_suffix () const + { + return m_special_routing_suffix; + } + + void set_special_routing_suffix (const std::string &s) + { + m_special_routing_suffix = s; + } + + int special_routing_datatype () const + { + return m_special_routing_datatype; + } + + void set_special_routing_datatype (int s) + { + m_special_routing_datatype = s; + } + void clear_lef_files () { m_lef_files.clear (); @@ -478,6 +538,9 @@ private: bool m_produce_pins; std::string m_pins_suffix; int m_pins_datatype; + bool m_produce_lef_pins; + std::string m_lef_pins_suffix; + int m_lef_pins_datatype; bool m_produce_obstructions; std::string m_obstructions_suffix; int m_obstructions_datatype; @@ -490,6 +553,9 @@ private: bool m_produce_routing; std::string m_routing_suffix; int m_routing_datatype; + bool m_produce_special_routing; + std::string m_special_routing_suffix; + int m_special_routing_datatype; bool m_separate_groups; std::vector m_lef_files; }; @@ -499,15 +565,17 @@ private: */ enum LayerPurpose { - Routing = 0, - ViaGeometry = 1, - Label = 2, - Pins = 3, - Obstructions = 4, - Outline = 5, - Blockage = 6, - PlacementBlockage = 7, - Region = 8 + Routing = 0, // from DEF only + SpecialRouting, // from DEF only + ViaGeometry, // from LEF+DEF + Label, // from LEF+DEF + Pins, // from DEF + LEFPins, // from LEF + Obstructions, // from LEF only + Outline, // from LEF+DEF + Blockage, // from DEF only + PlacementBlockage, // from DEF only + Region, // from DEF only }; /** diff --git a/src/plugins/streamers/lefdef/db_plugin/dbLEFDEFPlugin.cc b/src/plugins/streamers/lefdef/db_plugin/dbLEFDEFPlugin.cc index 5c196d026..699518e7a 100644 --- a/src/plugins/streamers/lefdef/db_plugin/dbLEFDEFPlugin.cc +++ b/src/plugins/streamers/lefdef/db_plugin/dbLEFDEFPlugin.cc @@ -96,9 +96,10 @@ read_map_file (const std::string &path, db::LEFDEFReaderState &layers) tl::TextInputStream ts (file_stream); std::map purpose_translation; - purpose_translation ["LEFPIN"] = "PIN"; + purpose_translation ["LEFPIN"] = "LEFPIN"; + purpose_translation ["PIN"] = "PIN"; purpose_translation ["LEFOBS"] = "OBS"; - purpose_translation ["SPNET"] = "NET"; + purpose_translation ["SPNET"] = "SPNET"; purpose_translation ["NET"] = "NET"; purpose_translation ["VIA"] = "VIA"; purpose_translation ["BLOCKAGE"] = "BLK"; @@ -406,6 +407,9 @@ class LEFDEFFormatDeclaration tl::make_member (&LEFDEFReaderOptions::produce_pins, &LEFDEFReaderOptions::set_produce_pins, "produce-pins") + tl::make_member (&LEFDEFReaderOptions::pins_suffix, &LEFDEFReaderOptions::set_pins_suffix, "pins-suffix") + tl::make_member (&LEFDEFReaderOptions::pins_datatype, &LEFDEFReaderOptions::set_pins_datatype, "pins-datatype") + + tl::make_member (&LEFDEFReaderOptions::produce_lef_pins, &LEFDEFReaderOptions::set_produce_lef_pins, "produce-lef-pins") + + tl::make_member (&LEFDEFReaderOptions::lef_pins_suffix, &LEFDEFReaderOptions::set_lef_pins_suffix, "lef-pins-suffix") + + tl::make_member (&LEFDEFReaderOptions::lef_pins_datatype, &LEFDEFReaderOptions::set_lef_pins_datatype, "lef-pins-datatype") + tl::make_member (&LEFDEFReaderOptions::produce_obstructions, &LEFDEFReaderOptions::set_produce_obstructions, "produce-obstructions") + tl::make_member (&LEFDEFReaderOptions::obstructions_suffix, &LEFDEFReaderOptions::set_obstructions_suffix, "obstructions-suffix") + tl::make_member (&LEFDEFReaderOptions::obstructions_datatype, &LEFDEFReaderOptions::set_obstructions_datatype, "obstructions-datatype") + @@ -418,6 +422,9 @@ class LEFDEFFormatDeclaration tl::make_member (&LEFDEFReaderOptions::produce_routing, &LEFDEFReaderOptions::set_produce_routing, "produce-routing") + tl::make_member (&LEFDEFReaderOptions::routing_suffix, &LEFDEFReaderOptions::set_routing_suffix, "routing-suffix") + tl::make_member (&LEFDEFReaderOptions::routing_datatype, &LEFDEFReaderOptions::set_routing_datatype, "routing-datatype") + + tl::make_member (&LEFDEFReaderOptions::produce_special_routing, &LEFDEFReaderOptions::set_produce_special_routing, "produce-special-routing") + + tl::make_member (&LEFDEFReaderOptions::special_routing_suffix, &LEFDEFReaderOptions::set_special_routing_suffix, "special-routing-suffix") + + tl::make_member (&LEFDEFReaderOptions::special_routing_datatype, &LEFDEFReaderOptions::set_special_routing_datatype, "special-routing-datatype") + tl::make_member (&LEFDEFReaderOptions::begin_lef_files, &LEFDEFReaderOptions::end_lef_files, &LEFDEFReaderOptions::push_lef_file, "lef-files") ); } diff --git a/src/plugins/streamers/lefdef/db_plugin/dbLEFImporter.cc b/src/plugins/streamers/lefdef/db_plugin/dbLEFImporter.cc index fccdd779b..090fdfae8 100644 --- a/src/plugins/streamers/lefdef/db_plugin/dbLEFImporter.cc +++ b/src/plugins/streamers/lefdef/db_plugin/dbLEFImporter.cc @@ -789,7 +789,7 @@ LEFImporter::read_macro (Layout &layout) } std::map bboxes; - read_geometries (layout, cell, Pins, &bboxes, prop_id); + read_geometries (layout, cell, LEFPins, &bboxes, prop_id); for (std::map ::const_iterator b = bboxes.begin (); b != bboxes.end (); ++b) { std::pair dl = open_layer (layout, b->first, Label); diff --git a/src/plugins/streamers/lefdef/db_plugin/gsiDeclDbLEFDEF.cc b/src/plugins/streamers/lefdef/db_plugin/gsiDeclDbLEFDEF.cc index 55191416e..6d31e64cc 100644 --- a/src/plugins/streamers/lefdef/db_plugin/gsiDeclDbLEFDEF.cc +++ b/src/plugins/streamers/lefdef/db_plugin/gsiDeclDbLEFDEF.cc @@ -296,6 +296,30 @@ gsi::Class decl_lefdef_config ("db", "LEFDEFReaderConfi "@brief Sets the pin geometry layer datatype value.\n" "See \\produce_via_geometry for details about the layer production rules." ) + + gsi::method ("produce_lef_pins", &db::LEFDEFReaderOptions::produce_lef_pins, + "@brief Gets a value indicating whether LEF pin geometries shall be produced.\n" + "See \\produce_via_geometry for details about the layer production rules." + ) + + gsi::method ("produce_lef_pins=", &db::LEFDEFReaderOptions::set_produce_lef_pins, gsi::arg ("produce"), + "@brief Sets a value indicating whether LEF pin geometries shall be produced.\n" + "See \\produce_via_geometry for details about the layer production rules." + ) + + gsi::method ("lef_pins_suffix", &db::LEFDEFReaderOptions::lef_pins_suffix, + "@brief Gets the LEF pin geometry layer name suffix.\n" + "See \\produce_via_geometry for details about the layer production rules." + ) + + gsi::method ("lef_pins_suffix=", &db::LEFDEFReaderOptions::set_lef_pins_suffix, gsi::arg ("suffix"), + "@brief Sets the LEF pin geometry layer name suffix.\n" + "See \\produce_via_geometry for details about the layer production rules." + ) + + gsi::method ("lef_pins_datatype", &db::LEFDEFReaderOptions::lef_pins_datatype, + "@brief Gets the LEF pin geometry layer datatype value.\n" + "See \\produce_via_geometry for details about the layer production rules." + ) + + gsi::method ("lef_pins_datatype=", &db::LEFDEFReaderOptions::set_lef_pins_datatype, gsi::arg ("datatype"), + "@brief Sets the LEF pin geometry layer datatype value.\n" + "See \\produce_via_geometry for details about the layer production rules." + ) + gsi::method ("produce_obstructions", &db::LEFDEFReaderOptions::produce_obstructions, "@brief Gets a value indicating whether obstruction markers shall be produced.\n" "See \\produce_via_geometry for details about the layer production rules." @@ -392,6 +416,42 @@ gsi::Class decl_lefdef_config ("db", "LEFDEFReaderConfi "@brief Sets the routing layer datatype value.\n" "See \\produce_via_geometry for details about the layer production rules." ) + + gsi::method ("produce_special_routing", &db::LEFDEFReaderOptions::produce_special_routing, + "@brief Gets a value indicating whether special routing geometry shall be produced.\n" + "See \\produce_via_geometry for details about the layer production rules.\n" + "\n" + "The differentiation between special and normal routing has been introduced in version 0.26.5." + ) + + gsi::method ("produce_special_routing=", &db::LEFDEFReaderOptions::set_produce_special_routing, gsi::arg ("produce"), + "@brief Sets a value indicating whether special routing geometry shall be produced.\n" + "See \\produce_via_geometry for details about the layer production rules." + "\n" + "The differentiation between special and normal routing has been introduced in version 0.26.5." + ) + + gsi::method ("special_routing_suffix", &db::LEFDEFReaderOptions::special_routing_suffix, + "@brief Gets the special routing layer name suffix.\n" + "See \\produce_via_geometry for details about the layer production rules." + "\n" + "The differentiation between special and normal routing has been introduced in version 0.26.5." + ) + + gsi::method ("special_routing_suffix=", &db::LEFDEFReaderOptions::set_special_routing_suffix, gsi::arg ("suffix"), + "@brief Sets the special routing layer name suffix.\n" + "See \\produce_via_geometry for details about the layer production rules." + "\n" + "The differentiation between special and normal routing has been introduced in version 0.26.5." + ) + + gsi::method ("special_routing_datatype", &db::LEFDEFReaderOptions::special_routing_datatype, + "@brief Gets the special routing layer datatype value.\n" + "See \\produce_via_geometry for details about the layer production rules." + "\n" + "The differentiation between special and normal routing has been introduced in version 0.26.5." + ) + + gsi::method ("special_routing_datatype=", &db::LEFDEFReaderOptions::set_special_routing_datatype, gsi::arg ("datatype"), + "@brief Sets the special routing layer datatype value.\n" + "See \\produce_via_geometry for details about the layer production rules." + "\n" + "The differentiation between special and normal routing has been introduced in version 0.26.5." + ) + gsi::method ("separate_groups", &db::LEFDEFReaderOptions::separate_groups, "@brief Gets a value indicating whether to create separate parent cells for individual groups.\n" "If this property is set to true, instances belonging to different groups are separated by putting them into " diff --git a/src/plugins/streamers/lefdef/lay_plugin/LEFDEFTechnologyComponentEditor.ui b/src/plugins/streamers/lefdef/lay_plugin/LEFDEFTechnologyComponentEditor.ui index 3833de8a3..845452c8e 100644 --- a/src/plugins/streamers/lefdef/lay_plugin/LEFDEFTechnologyComponentEditor.ui +++ b/src/plugins/streamers/lefdef/lay_plugin/LEFDEFTechnologyComponentEditor.ui @@ -590,13 +590,6 @@ - - - - Obstructions - - - @@ -613,19 +606,6 @@ - - - - - - - - - - Routing - - - @@ -642,43 +622,14 @@ - - - - - - - - - - Pin labels - - - - + Blockages - - - - - 0 - 0 - - - - - - - :/right.png - - - - + @@ -694,18 +645,125 @@ - - - - - - - + - + + + + + + 0 + 0 + + + + + + + :/right.png + + + + + + + + 0 + 0 + + + + + + + :/right.png + + + + + + + + 0 + 0 + + + + + + + :/right.png + + + + + + + Pin labels + + + + + + + + + + + + + Special routing + + + + + + + + + + + + + Routing + + + + + + + + + + + + + Obstructions + + + + + + + + + + + + + + + + + + + LEF Pins + + + diff --git a/src/plugins/streamers/lefdef/lay_plugin/layLEFDEFImportDialogs.cc b/src/plugins/streamers/lefdef/lay_plugin/layLEFDEFImportDialogs.cc index 8aeef44bd..16b70262d 100644 --- a/src/plugins/streamers/lefdef/lay_plugin/layLEFDEFImportDialogs.cc +++ b/src/plugins/streamers/lefdef/lay_plugin/layLEFDEFImportDialogs.cc @@ -353,9 +353,11 @@ LEFDEFReaderOptionsEditor::LEFDEFReaderOptionsEditor (QWidget *parent) connect (produce_regions, SIGNAL (stateChanged (int)), this, SLOT (checkbox_changed ())); connect (produce_via_geometry, SIGNAL (stateChanged (int)), this, SLOT (checkbox_changed ())); connect (produce_pins, SIGNAL (stateChanged (int)), this, SLOT (checkbox_changed ())); + connect (produce_lef_pins, SIGNAL (stateChanged (int)), this, SLOT (checkbox_changed ())); connect (produce_obstructions, SIGNAL (stateChanged (int)), this, SLOT (checkbox_changed ())); connect (produce_blockages, SIGNAL (stateChanged (int)), this, SLOT (checkbox_changed ())); connect (produce_routing, SIGNAL (stateChanged (int)), this, SLOT (checkbox_changed ())); + connect (produce_special_routing, SIGNAL (stateChanged (int)), this, SLOT (checkbox_changed ())); connect (produce_labels, SIGNAL (stateChanged (int)), this, SLOT (checkbox_changed ())); connect (add_lef_file, SIGNAL (clicked ()), this, SLOT (add_lef_file_clicked ())); connect (del_lef_files, SIGNAL (clicked ()), this, SLOT (del_lef_files_clicked ())); @@ -429,6 +431,9 @@ LEFDEFReaderOptionsEditor::commit (db::FormatSpecificReaderOptions *options, con data->set_produce_pins (produce_pins->isChecked ()); data->set_pins_suffix (tl::to_string (suffix_pins->text ())); data->set_pins_datatype (datatype_pins->text ().toInt ()); + data->set_produce_lef_pins (produce_lef_pins->isChecked ()); + data->set_lef_pins_suffix (tl::to_string (suffix_lef_pins->text ())); + data->set_lef_pins_datatype (datatype_lef_pins->text ().toInt ()); data->set_produce_obstructions (produce_obstructions->isChecked ()); data->set_obstructions_suffix (tl::to_string (suffix_obstructions->text ())); data->set_obstructions_datatype (datatype_obstructions->text ().toInt ()); @@ -438,6 +443,9 @@ LEFDEFReaderOptionsEditor::commit (db::FormatSpecificReaderOptions *options, con data->set_produce_routing (produce_routing->isChecked ()); data->set_routing_suffix (tl::to_string (suffix_routing->text ())); data->set_routing_datatype (datatype_routing->text ().toInt ()); + data->set_produce_special_routing (produce_special_routing->isChecked ()); + data->set_special_routing_suffix (tl::to_string (suffix_special_routing->text ())); + data->set_special_routing_datatype (datatype_special_routing->text ().toInt ()); data->set_produce_labels (produce_labels->isChecked ()); data->set_labels_suffix (tl::to_string (suffix_labels->text ())); data->set_labels_datatype (datatype_labels->text ().toInt ()); @@ -483,6 +491,9 @@ LEFDEFReaderOptionsEditor::setup (const db::FormatSpecificReaderOptions *options produce_pins->setChecked (data->produce_pins ()); suffix_pins->setText (tl::to_qstring (data->pins_suffix ())); datatype_pins->setText (QString::number (data->pins_datatype ())); + produce_lef_pins->setChecked (data->produce_lef_pins ()); + suffix_lef_pins->setText (tl::to_qstring (data->lef_pins_suffix ())); + datatype_lef_pins->setText (QString::number (data->lef_pins_datatype ())); produce_obstructions->setChecked (data->produce_obstructions ()); suffix_obstructions->setText (tl::to_qstring (data->obstructions_suffix ())); datatype_obstructions->setText (QString::number (data->obstructions_datatype ())); @@ -492,6 +503,9 @@ LEFDEFReaderOptionsEditor::setup (const db::FormatSpecificReaderOptions *options produce_routing->setChecked (data->produce_routing ()); suffix_routing->setText (tl::to_qstring (data->routing_suffix ())); datatype_routing->setText (QString::number (data->routing_datatype ())); + produce_special_routing->setChecked (data->produce_special_routing ()); + suffix_special_routing->setText (tl::to_qstring (data->special_routing_suffix ())); + datatype_special_routing->setText (QString::number (data->special_routing_datatype ())); produce_labels->setChecked (data->produce_labels ()); suffix_labels->setText (tl::to_qstring (data->labels_suffix ())); datatype_labels->setText (QString::number (data->labels_datatype ())); @@ -523,15 +537,19 @@ LEFDEFReaderOptionsEditor::checkbox_changed () placement_blockage_layer->setEnabled (produce_placement_blockages->isChecked ()); suffix_via_geometry->setEnabled (produce_via_geometry->isChecked ()); suffix_pins->setEnabled (produce_pins->isChecked ()); + suffix_lef_pins->setEnabled (produce_lef_pins->isChecked ()); suffix_obstructions->setEnabled (produce_obstructions->isChecked ()); suffix_blockages->setEnabled (produce_blockages->isChecked ()); suffix_routing->setEnabled (produce_routing->isChecked ()); + suffix_special_routing->setEnabled (produce_special_routing->isChecked ()); suffix_labels->setEnabled (produce_labels->isChecked ()); datatype_via_geometry->setEnabled (produce_via_geometry->isChecked ()); datatype_pins->setEnabled (produce_pins->isChecked ()); + datatype_lef_pins->setEnabled (produce_lef_pins->isChecked ()); datatype_obstructions->setEnabled (produce_obstructions->isChecked ()); datatype_blockages->setEnabled (produce_blockages->isChecked ()); datatype_routing->setEnabled (produce_routing->isChecked ()); + datatype_special_routing->setEnabled (produce_special_routing->isChecked ()); datatype_labels->setEnabled (produce_labels->isChecked ()); } diff --git a/src/plugins/streamers/lefdef/unit_tests/dbLEFDEFImportTests.cc b/src/plugins/streamers/lefdef/unit_tests/dbLEFDEFImportTests.cc index 7dbd7772c..45b21683b 100644 --- a/src/plugins/streamers/lefdef/unit_tests/dbLEFDEFImportTests.cc +++ b/src/plugins/streamers/lefdef/unit_tests/dbLEFDEFImportTests.cc @@ -295,6 +295,19 @@ TEST(104_doxy_vias) TEST(105_specialnets_geo) { run_test (_this, "specialnets_geo", "lef:test.lef+def:test.def", "au.oas.gz", default_options (), false); + + db::LEFDEFReaderOptions options = default_options (); + options.set_produce_special_routing (false); + run_test (_this, "specialnets_geo", "lef:test.lef+def:test.def", "au_no_spnet.oas.gz", options, false); + + options.set_produce_special_routing (true); + options.set_special_routing_datatype (10); + options.set_special_routing_suffix (".SPNET"); + + options.set_via_geometry_datatype (11); + options.set_via_geometry_suffix (".VIA"); + + run_test (_this, "specialnets_geo", "lef:test.lef+def:test.def", "au_spnet_mapped.oas.gz", options, false); } TEST(106_wrongdirection) @@ -315,4 +328,14 @@ TEST(108_scanchain) TEST(109_foreigncell) { run_test (_this, "foreigncell", "gds:foreign.gds+lef:in_tech.lef+lef:in.lef", "au.oas.gz", default_options (), false); + + db::LEFDEFReaderOptions options = default_options (); + options.set_produce_lef_pins (false); + run_test (_this, "foreigncell", "gds:foreign.gds+lef:in_tech.lef+lef:in.lef", "au_no_lefpins.oas.gz", options, false); + + options.set_produce_lef_pins (true); + options.set_lef_pins_datatype (10); + options.set_lef_pins_suffix (".LEFPIN"); + + run_test (_this, "foreigncell", "gds:foreign.gds+lef:in_tech.lef+lef:in.lef", "au_lefpins_mapped.oas.gz", options, false); } diff --git a/testdata/lefdef/foreigncell/au_lefpins_mapped.oas.gz b/testdata/lefdef/foreigncell/au_lefpins_mapped.oas.gz new file mode 100644 index 000000000..7416d50b6 Binary files /dev/null and b/testdata/lefdef/foreigncell/au_lefpins_mapped.oas.gz differ diff --git a/testdata/lefdef/foreigncell/au_no_lefpins.oas.gz b/testdata/lefdef/foreigncell/au_no_lefpins.oas.gz new file mode 100644 index 000000000..f0e21a209 Binary files /dev/null and b/testdata/lefdef/foreigncell/au_no_lefpins.oas.gz differ diff --git a/testdata/lefdef/specialnets_geo/au_no_spnet.oas.gz b/testdata/lefdef/specialnets_geo/au_no_spnet.oas.gz new file mode 100644 index 000000000..4bf45b031 Binary files /dev/null and b/testdata/lefdef/specialnets_geo/au_no_spnet.oas.gz differ diff --git a/testdata/lefdef/specialnets_geo/au_spnet_mapped.oas.gz b/testdata/lefdef/specialnets_geo/au_spnet_mapped.oas.gz new file mode 100644 index 000000000..7decf1260 Binary files /dev/null and b/testdata/lefdef/specialnets_geo/au_spnet_mapped.oas.gz differ diff --git a/testdata/ruby/dbReaders.rb b/testdata/ruby/dbReaders.rb index 9cc558f75..c874c782f 100644 --- a/testdata/ruby/dbReaders.rb +++ b/testdata/ruby/dbReaders.rb @@ -269,6 +269,18 @@ class DBReaders_TestClass < TestBase conf.pins_datatype = 18 assert_equal(conf.pins_datatype, 18) + assert_equal(conf.produce_lef_pins, true) + conf.produce_lef_pins = false + assert_equal(conf.produce_lef_pins, false) + + assert_equal(conf.lef_pins_suffix, ".PIN") + conf.lef_pins_suffix = "LEFPIN" + assert_equal(conf.lef_pins_suffix, "LEFPIN") + + assert_equal(conf.lef_pins_datatype, 2) + conf.lef_pins_datatype = 181 + assert_equal(conf.lef_pins_datatype, 181) + assert_equal(conf.produce_obstructions, true) conf.produce_obstructions = false assert_equal(conf.produce_obstructions, false) @@ -317,6 +329,18 @@ class DBReaders_TestClass < TestBase conf.routing_datatype = 22 assert_equal(conf.routing_datatype, 22) + assert_equal(conf.produce_special_routing, true) + conf.produce_special_routing = false + assert_equal(conf.produce_special_routing, false) + + assert_equal(conf.special_routing_suffix, "") + conf.special_routing_suffix = "SPROUT" + assert_equal(conf.special_routing_suffix, "SPROUT") + + assert_equal(conf.special_routing_datatype, 0) + conf.special_routing_datatype = 23 + assert_equal(conf.special_routing_datatype, 23) + assert_equal(conf.separate_groups, false) conf.separate_groups = true assert_equal(conf.separate_groups, true)