861 lines
25 KiB
C++
861 lines
25 KiB
C++
// ****************************************************************************************************
|
|
// File: Cell.cpp
|
|
// Authors: R. Escassut
|
|
// Copyright (c) BULL S.A. 2000-2004, All Rights Reserved
|
|
// ****************************************************************************************************
|
|
|
|
#include "Cell.h"
|
|
#include "DataBase.h"
|
|
#include "Library.h"
|
|
#include "Instance.h"
|
|
#include "Net.h"
|
|
#include "Pin.h"
|
|
#include "RoutingPad.h"
|
|
#include "Layer.h"
|
|
#include "Slice.h"
|
|
#include "Rubber.h"
|
|
#include "Marker.h"
|
|
#include "Symbol.h"
|
|
#include "Primitive.h"
|
|
#include "MapView.h"
|
|
#include "DisplaySlot.h"
|
|
#include "Component.h"
|
|
#include "UpdateSession.h"
|
|
#include "Error.h"
|
|
|
|
namespace Hurricane {
|
|
|
|
// ****************************************************************************************************
|
|
// Cell implementation
|
|
// ****************************************************************************************************
|
|
|
|
Cell::Cell(Library* library, const Name& name)
|
|
// *******************************************
|
|
: Inherit(),
|
|
_library(library),
|
|
_name(name),
|
|
_instanceMap(),
|
|
_quadTree(),
|
|
_slaveInstanceSet(),
|
|
_netMap(),
|
|
_sliceMap(),
|
|
_markerSet(),
|
|
_viewSet(),
|
|
_abutmentBox(),
|
|
_boundingBox(),
|
|
_isTerminal(true),
|
|
_isPad(false),
|
|
_symbol(NULL),
|
|
_nextOfLibraryCellMap(NULL),
|
|
_nextOfSymbolCellSet(NULL),
|
|
_slaveEntityMap()
|
|
{
|
|
if (!_library)
|
|
throw Error("Can't create " + _TName("Cell") + " : null library");
|
|
|
|
if (name.IsEmpty())
|
|
throw Error("Can't create " + _TName("Cell") + " : empty name");
|
|
|
|
if (_library->GetCell(_name))
|
|
throw Error("Can't create " + _TName("Cell") + " : already exists");
|
|
}
|
|
|
|
Cell* Cell::Create(Library* library, const Name& name)
|
|
// ***************************************************
|
|
{
|
|
Cell* cell = new Cell(library, name);
|
|
|
|
cell->_PostCreate();
|
|
|
|
return cell;
|
|
}
|
|
|
|
Box Cell::GetBoundingBox() const
|
|
// *****************************
|
|
{
|
|
if (_boundingBox.IsEmpty()) {
|
|
Box& boundingBox = (Box&)_boundingBox;
|
|
boundingBox = _abutmentBox;
|
|
boundingBox.Merge(_quadTree.GetBoundingBox());
|
|
for_each_slice(slice, GetSlices()) {
|
|
boundingBox.Merge(slice->GetBoundingBox());
|
|
end_for;
|
|
}
|
|
}
|
|
|
|
return _boundingBox;
|
|
}
|
|
|
|
bool Cell::IsLeaf() const
|
|
// **********************
|
|
{
|
|
return _instanceMap.IsEmpty();
|
|
}
|
|
|
|
bool Cell::IsCalledBy(Cell* cell) const
|
|
// ************************************
|
|
{
|
|
for_each_instance(instance, cell->GetInstances()) {
|
|
Cell* masterCell = instance->GetMasterCell();
|
|
if (masterCell == this) return true;
|
|
if (IsCalledBy(masterCell)) return true;
|
|
end_for;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void Cell::SetName(const Name& name)
|
|
// *********************************
|
|
{
|
|
if (name != _name) {
|
|
if (name.IsEmpty())
|
|
throw Error("Can't change " + _TName("Cell") + " name : empty name");
|
|
|
|
if (_library->GetCell(name))
|
|
throw Error("Can't change " + _TName("Cell") + " name : already exists");
|
|
|
|
_library->_GetCellMap()._Remove(this);
|
|
_name = name;
|
|
_library->_GetCellMap()._Insert(this);
|
|
}
|
|
}
|
|
|
|
void Cell::SetAbutmentBox(const Box& abutmentBox)
|
|
// **********************************************
|
|
{
|
|
if (abutmentBox != _abutmentBox) {
|
|
if (!_abutmentBox.IsEmpty() &&
|
|
(abutmentBox.IsEmpty() || !abutmentBox.Contains(_abutmentBox)))
|
|
_Unfit(_abutmentBox);
|
|
_abutmentBox = abutmentBox;
|
|
_Fit(_abutmentBox);
|
|
}
|
|
}
|
|
|
|
void Cell::SetSymbol(Symbol* symbol)
|
|
// *********************************
|
|
{
|
|
if (symbol != _symbol) {
|
|
OpenUpdateSession();
|
|
if (_symbol) {
|
|
_Unfit(_symbol->GetBoundingBox());
|
|
for_each_net(net, GetExternalNets()) {
|
|
net->SetPosition(Point(0, 0));
|
|
end_for;
|
|
}
|
|
_symbol->_GetCellSet()._Remove(this);
|
|
}
|
|
_symbol = symbol;
|
|
if (_symbol) {
|
|
_symbol->_GetCellSet()._Insert(this);
|
|
for_each_net(net, GetExternalNets()) {
|
|
Port* port = _symbol->GetPort(net->GetName());
|
|
if (port) net->SetPosition(port->GetPosition());
|
|
end_for;
|
|
}
|
|
_Fit(_symbol->GetBoundingBox());
|
|
}
|
|
CloseUpdateSession();
|
|
}
|
|
}
|
|
|
|
void Cell::FlattenNets(bool buildRings)
|
|
// ************************************
|
|
{
|
|
OpenUpdateSession ();
|
|
|
|
for_each_occurrence ( occurrence, GetHyperNetRootNetOccurrences() ) {
|
|
HyperNet hyperNet ( occurrence );
|
|
if ( !occurrence.GetPath().IsEmpty() ) {
|
|
DeepNet* deepNet = DeepNet::Create ( hyperNet );
|
|
if (deepNet) deepNet->_CreateRoutingPads ( buildRings );
|
|
} else {
|
|
RoutingPad* previousRP = NULL;
|
|
RoutingPad* currentRP = NULL;
|
|
Net* net = static_cast<Net*>(occurrence.GetEntity());
|
|
|
|
for_each_component ( component, net->GetComponents() ) {
|
|
Plug* primaryPlug = dynamic_cast<Plug*>( component );
|
|
if ( primaryPlug ) {
|
|
if ( !primaryPlug->GetBodyHook()->GetSlaveHooks().IsEmpty() ) {
|
|
cerr << "[ERROR] " << primaryPlug << "\n"
|
|
<< " has attached components, not managed yet." << endl;
|
|
} else {
|
|
primaryPlug->GetBodyHook()->Detach ();
|
|
}
|
|
}
|
|
end_for
|
|
}
|
|
|
|
for_each_occurrence ( plugOccurrence, hyperNet.GetLeafPlugOccurrences() ) {
|
|
currentRP = CreateRoutingPad ( net, plugOccurrence );
|
|
currentRP->Materialize ();
|
|
if ( buildRings ) {
|
|
if ( previousRP ) {
|
|
currentRP->GetBodyHook()->Attach ( previousRP->GetBodyHook() );
|
|
}
|
|
Plug* plug = static_cast<Plug*>( plugOccurrence.GetEntity() );
|
|
if ( plugOccurrence.GetPath().IsEmpty() ) {
|
|
plug->GetBodyHook()->Attach ( currentRP->GetBodyHook() );
|
|
plug->GetBodyHook()->Detach ();
|
|
}
|
|
previousRP = currentRP;
|
|
}
|
|
|
|
end_for
|
|
}
|
|
|
|
for_each_component ( component, net->GetComponents() ) {
|
|
Pin* pin = dynamic_cast<Pin*>( component );
|
|
if ( pin ) {
|
|
currentRP = CreateRoutingPad ( pin );
|
|
if ( buildRings ) {
|
|
if ( previousRP ) {
|
|
currentRP->GetBodyHook()->Attach ( previousRP->GetBodyHook() );
|
|
}
|
|
pin->GetBodyHook()->Attach ( currentRP->GetBodyHook() );
|
|
pin->GetBodyHook()->Detach ();
|
|
}
|
|
previousRP = currentRP;
|
|
}
|
|
|
|
end_for
|
|
}
|
|
}
|
|
end_for
|
|
}
|
|
|
|
CloseUpdateSession ();
|
|
}
|
|
|
|
void Cell::Materialize()
|
|
// *********************
|
|
{
|
|
for_each_instance(instance, GetInstances()) instance->Materialize(); end_for;
|
|
for_each_net(net, GetNets()) net->Materialize(); end_for;
|
|
for_each_marker(marker, GetMarkers()) marker->Materialize(); end_for;
|
|
}
|
|
|
|
void Cell::Unmaterialize()
|
|
// ***********************
|
|
{
|
|
for_each_instance(instance, GetInstances()) instance->Unmaterialize(); end_for;
|
|
for_each_net(net, GetNets()) net->Unmaterialize(); end_for;
|
|
for_each_marker(marker, GetMarkers()) marker->Unmaterialize(); end_for;
|
|
}
|
|
|
|
void Cell::_PostCreate()
|
|
// *********************
|
|
{
|
|
_library->_GetCellMap()._Insert(this);
|
|
|
|
Inherit::_PostCreate();
|
|
}
|
|
|
|
void Cell::_PreDelete()
|
|
// ********************
|
|
{
|
|
Inherit::_PreDelete();
|
|
|
|
while(_slaveEntityMap.size()) {
|
|
_slaveEntityMap.begin()->second->Delete();
|
|
}
|
|
|
|
if (_symbol) SetSymbol(NULL);
|
|
|
|
for_each_view(view, GetViews()) view->SetCell(NULL); end_for;
|
|
for_each_marker(marker, GetMarkers()) marker->Delete(); end_for;
|
|
for_each_instance(slaveInstance, GetSlaveInstances()) slaveInstance->Delete(); end_for;
|
|
for_each_instance(instance, GetInstances()) instance->Delete(); end_for;
|
|
for_each_net(net, GetNets()) net->Delete(); end_for;
|
|
for_each_slice(slice, GetSlices()) slice->_Delete(); end_for;
|
|
|
|
_library->_GetCellMap()._Remove(this);
|
|
}
|
|
|
|
string Cell::_GetString() const
|
|
// ****************************
|
|
{
|
|
string s = Inherit::_GetString();
|
|
s.insert(s.length() - 1, " " + GetString(_name));
|
|
return s;
|
|
}
|
|
|
|
Record* Cell::_GetRecord() const
|
|
// ***********************
|
|
{
|
|
Record* record = Inherit::_GetRecord();
|
|
if (record) {
|
|
record->Add(GetSlot("Library", _library));
|
|
record->Add(GetSlot("Name", &_name));
|
|
record->Add(GetSlot("Instances", &_instanceMap));
|
|
record->Add(GetSlot("QuadTree", &_quadTree));
|
|
record->Add(GetSlot("SlaveInstances", &_slaveInstanceSet));
|
|
record->Add(GetSlot("Nets", &_netMap));
|
|
record->Add(GetSlot("Pins", &_pinMap));
|
|
record->Add(GetSlot("Slices", &_sliceMap));
|
|
record->Add(GetSlot("Markers", &_markerSet));
|
|
record->Add(GetSlot("Views", &_viewSet));
|
|
record->Add(GetSlot("AbutmentBox", &_abutmentBox));
|
|
record->Add(GetSlot("BoundingBox", &_boundingBox));
|
|
record->Add(GetSlot("IsTerminal", &_isTerminal));
|
|
record->Add(GetSlot("IsFlattenLeaf", &_isFlattenLeaf));
|
|
//record->Add(GetSlot("Symbol", _symbol));
|
|
}
|
|
return record;
|
|
}
|
|
|
|
void Cell::_Fit(const Box& box)
|
|
// ****************************
|
|
{
|
|
if (box.IsEmpty()) return;
|
|
if (_boundingBox.IsEmpty()) return;
|
|
if (_boundingBox.Contains(box)) return;
|
|
_boundingBox.Merge(box);
|
|
for_each_instance(instance, GetSlaveInstances()) {
|
|
instance->GetCell()->_Fit(instance->GetTransformation().GetBox(box));
|
|
end_for;
|
|
}
|
|
}
|
|
|
|
void Cell::_Unfit(const Box& box)
|
|
// ******************************
|
|
{
|
|
if (box.IsEmpty()) return;
|
|
if (_boundingBox.IsEmpty()) return;
|
|
if (!_boundingBox.IsConstrainedBy(box)) return;
|
|
_boundingBox.MakeEmpty();
|
|
for_each_instance(instance, GetSlaveInstances()) {
|
|
instance->GetCell()->_Unfit(instance->GetTransformation().GetBox(box));
|
|
end_for;
|
|
}
|
|
}
|
|
|
|
void Cell::_AddSlaveEntity(Entity* entity, Entity* slaveEntity)
|
|
// ************************************************************************
|
|
{
|
|
assert(entity->GetCell() == this);
|
|
|
|
_slaveEntityMap.insert(pair<Entity*,Entity*>(entity,slaveEntity));
|
|
}
|
|
|
|
void Cell::_RemoveSlaveEntity(Entity* entity, Entity* slaveEntity)
|
|
// ***************************************************************************
|
|
{
|
|
assert(entity->GetCell() == this);
|
|
|
|
pair<SlaveEntityMap::iterator,SlaveEntityMap::iterator>
|
|
bounds = _slaveEntityMap.equal_range(entity);
|
|
multimap<Entity*,Entity*>::iterator it = bounds.first;
|
|
for(; it != bounds.second ; it++ ) {
|
|
if (it->second == slaveEntity) {
|
|
_slaveEntityMap.erase(it);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Cell::_GetSlaveEntities(SlaveEntityMap::iterator& begin, SlaveEntityMap::iterator& end)
|
|
// *********************************************************************************************************
|
|
{
|
|
begin = _slaveEntityMap.begin();
|
|
end = _slaveEntityMap.end();
|
|
}
|
|
|
|
void Cell::_GetSlaveEntities(Entity* entity, SlaveEntityMap::iterator& begin, SlaveEntityMap::iterator& end)
|
|
// *********************************************************************************************************
|
|
{
|
|
begin = _slaveEntityMap.lower_bound(entity);
|
|
end = _slaveEntityMap.upper_bound(entity);
|
|
}
|
|
|
|
bool Cell::_IsDrawable(View* view) const
|
|
// *************************************
|
|
{
|
|
if (view->GetCell() == this) return true;
|
|
|
|
if (is_a<MapView*>(view)) return true;
|
|
|
|
return (1 < (double)view->GetScreenSize(_boundingBox.GetHeight()));
|
|
// return (100 < ((double)view->GetScreenSize(_boundingBox.GetWidth()) *
|
|
// (double)view->GetScreenSize(_boundingBox.GetHeight())));
|
|
}
|
|
|
|
bool Cell::_ContentIsDrawable(View* view) const
|
|
// ********************************************
|
|
{
|
|
if (IsTerminal()) return false;
|
|
|
|
if (view->GetCell() == this) return true;
|
|
|
|
if (is_a<MapView*>(view)) return false;
|
|
|
|
return (40 < (double)view->GetScreenSize(_boundingBox.GetHeight()));
|
|
// return (400 < ((double)view->GetScreenSize(_boundingBox.GetWidth()) *
|
|
// (double)view->GetScreenSize(_boundingBox.GetHeight())));
|
|
}
|
|
|
|
void Cell::_DrawPhantoms(View* view, const Box& updateArea, const Transformation& transformation)
|
|
// **********************************************************************************************
|
|
{
|
|
if (_IsDrawable(view)) { // To avoid irregular display of instances phantoms
|
|
if (!_ContentIsDrawable(view))
|
|
view->FillRectangle(transformation.GetBox(GetAbutmentBox()));
|
|
else {
|
|
for_each_instance(instance, GetInstancesUnder(updateArea)) {
|
|
instance->_DrawPhantoms(view, updateArea, transformation);
|
|
end_for;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Cell::_DrawBoundaries(View* view, const Box& updateArea, const Transformation& transformation)
|
|
// ************************************************************************************************
|
|
{
|
|
if (_IsDrawable(view)) { // To avoid irregular display of instances phantoms
|
|
view->DrawRectangle(transformation.GetBox(GetAbutmentBox()));
|
|
if (_ContentIsDrawable(view)) {
|
|
for_each_instance(instance, GetInstancesUnder(updateArea)) {
|
|
instance->_DrawBoundaries(view, updateArea, transformation);
|
|
end_for;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Cell::_DrawContent(View* view, BasicLayer* basicLayer, const Box& updateArea, const Transformation& transformation)
|
|
// ****************************************************************************************************
|
|
{
|
|
if (_IsDrawable(view)) {
|
|
if (_ContentIsDrawable(view)) {
|
|
view->CheckForDisplayInterruption();
|
|
for_each_instance(instance, GetInstancesUnder(updateArea)) {
|
|
instance->_Draw(view, basicLayer, updateArea, transformation);
|
|
end_for;
|
|
}
|
|
for_each_slice(slice, GetSlices()) {
|
|
slice->_Draw(view, basicLayer, updateArea, transformation);
|
|
end_for;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Cell::_DrawRubbers(View* view, const Box& updateArea, const Transformation& transformation)
|
|
// *********************************************************************************************
|
|
{
|
|
if (_IsDrawable(view)) {
|
|
if (_ContentIsDrawable(view)) {
|
|
for_each_instance(instance, GetInstancesUnder(updateArea)) {
|
|
instance->_DrawRubbers(view, updateArea, transformation);
|
|
end_for;
|
|
}
|
|
for_each_rubber(rubber, GetRubbersUnder(updateArea)) {
|
|
rubber->_Draw(view, NULL, updateArea, transformation);
|
|
end_for;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Cell::_DrawMarkers(View* view, const Box& updateArea, const Transformation& transformation)
|
|
// *********************************************************************************************
|
|
{
|
|
if (_IsDrawable(view)) {
|
|
if (_ContentIsDrawable(view)) {
|
|
for_each_instance(instance, GetInstancesUnder(updateArea)) {
|
|
instance->_DrawMarkers(view, updateArea, transformation);
|
|
end_for;
|
|
}
|
|
for_each_marker(marker, GetMarkersUnder(updateArea)) {
|
|
marker->_Draw(view, NULL, updateArea, transformation);
|
|
end_for;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Cell::_DrawDisplaySlots(View* view, const Box& area, const Box& updateArea, const Transformation& transformation)
|
|
// ********************************************************************************************************************
|
|
{
|
|
if (_IsDrawable(view)) {
|
|
if (_ContentIsDrawable(view)) {
|
|
for_each_instance(instance, GetInstancesUnder(updateArea)) {
|
|
instance->_DrawDisplaySlots(view, area, updateArea, transformation);
|
|
end_for;
|
|
}
|
|
for_each_display_slot(displaySlot, GetDisplaySlots(this)) {
|
|
view->_DrawDisplaySlot(displaySlot, area, updateArea, transformation);
|
|
end_for;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Cell::_SaveHeaderTo(OutputFile& outputFile)
|
|
// *********************************************
|
|
{
|
|
outputFile.Register(this);
|
|
|
|
Inherit::_SaveHeaderTo(outputFile);
|
|
|
|
outputFile << " " << outputFile.GetId(GetLibrary());
|
|
outputFile << " " << GetName();
|
|
outputFile << " " << GetValueString(GetAbutmentBox().GetXMin());
|
|
outputFile << " " << GetValueString(GetAbutmentBox().GetYMin());
|
|
outputFile << " " << GetValueString(GetAbutmentBox().GetXMax());
|
|
outputFile << " " << GetValueString(GetAbutmentBox().GetYMax());
|
|
outputFile << " " << ((IsTerminal()) ? '1' : '0');
|
|
}
|
|
|
|
void Cell::_SaveContentTo(OutputFile& outputFile)
|
|
// **********************************************
|
|
{
|
|
Inherit::_SaveContentTo(outputFile);
|
|
|
|
for_each_instance(instance, GetInstances()) {
|
|
instance->_SaveTo(outputFile);
|
|
end_for;
|
|
}
|
|
|
|
for_each_net(net, GetNets()) {
|
|
net->_SaveTo(outputFile);
|
|
end_for;
|
|
}
|
|
}
|
|
|
|
void Cell::_Realize(Hurricane::Builder* builder, InputFile& inputFile)
|
|
// *******************************************************************
|
|
{
|
|
assert(is_a<Cell::Builder*>(builder));
|
|
|
|
Cell::Builder* cellBuilder = (Cell::Builder*)builder;
|
|
|
|
SetAbutmentBox(cellBuilder->GetAbutmentBox());
|
|
SetTerminal(cellBuilder->IsTerminal());
|
|
|
|
// PROVISOIREMENT
|
|
string s = GetString(GetName());
|
|
Library* library = GetLibrary();
|
|
while (library) {
|
|
s = GetString(library->GetName()) + "/" + s;
|
|
library = library->GetLibrary();
|
|
}
|
|
cout << " Loading cell " << s << endl;
|
|
// PROVISOIREMENT
|
|
|
|
inputFile.Register(this);
|
|
|
|
Go::DisableAutoMaterialization();
|
|
|
|
OpenUpdateSession();
|
|
|
|
Inherit::_Realize(builder, inputFile);
|
|
}
|
|
|
|
void Cell::_Finalize(InputFile& inputFile)
|
|
// ***************************************
|
|
{
|
|
CloseUpdateSession();
|
|
|
|
Go::EnableAutoMaterialization();
|
|
|
|
Materialize();
|
|
|
|
Inherit::_Finalize(inputFile);
|
|
}
|
|
|
|
|
|
|
|
// ****************************************************************************************************
|
|
// Cell::InstanceMap implementation
|
|
// ****************************************************************************************************
|
|
|
|
Cell::InstanceMap::InstanceMap()
|
|
// *****************************
|
|
: Inherit()
|
|
{
|
|
}
|
|
|
|
Name Cell::InstanceMap::_GetKey(Instance* instance) const
|
|
// ******************************************************
|
|
{
|
|
return instance->GetName();
|
|
}
|
|
|
|
unsigned Cell::InstanceMap::_GetHashValue(Name name) const
|
|
// *******************************************************
|
|
{
|
|
return ( (unsigned int)( (unsigned long)name._GetSharedName() ) ) / 8;
|
|
}
|
|
|
|
Instance* Cell::InstanceMap::_GetNextElement(Instance* instance) const
|
|
// *******************************************************************
|
|
{
|
|
return instance->_GetNextOfCellInstanceMap();
|
|
}
|
|
|
|
void Cell::InstanceMap::_SetNextElement(Instance* instance, Instance* nextInstance) const
|
|
// **************************************************************************************
|
|
{
|
|
instance->_SetNextOfCellInstanceMap(nextInstance);
|
|
}
|
|
|
|
|
|
|
|
// ****************************************************************************************************
|
|
// Cell::SlaveInstanceSet implementation
|
|
// ****************************************************************************************************
|
|
|
|
Cell::SlaveInstanceSet::SlaveInstanceSet()
|
|
// ***************************************
|
|
: Inherit()
|
|
{
|
|
}
|
|
|
|
unsigned Cell::SlaveInstanceSet::_GetHashValue(Instance* slaveInstance) const
|
|
// **************************************************************************
|
|
{
|
|
return ( (unsigned int)( (unsigned long)slaveInstance ) ) / 8;
|
|
}
|
|
|
|
Instance* Cell::SlaveInstanceSet::_GetNextElement(Instance* slaveInstance) const
|
|
// *****************************************************************************
|
|
{
|
|
return slaveInstance->_GetNextOfCellSlaveInstanceSet();
|
|
}
|
|
|
|
void Cell::SlaveInstanceSet::_SetNextElement(Instance* slaveInstance, Instance* nextSlaveInstance) const
|
|
// ****************************************************************************************************
|
|
{
|
|
slaveInstance->_SetNextOfCellSlaveInstanceSet(nextSlaveInstance);
|
|
}
|
|
|
|
|
|
|
|
// ****************************************************************************************************
|
|
// Cell::NetMap implementation
|
|
// ****************************************************************************************************
|
|
|
|
Cell::NetMap::NetMap()
|
|
// *******************
|
|
: Inherit()
|
|
{
|
|
}
|
|
|
|
Name Cell::NetMap::_GetKey(Net* net) const
|
|
// ***************************************
|
|
{
|
|
return net->GetName();
|
|
}
|
|
|
|
unsigned Cell::NetMap::_GetHashValue(Name name) const
|
|
// **************************************************
|
|
{
|
|
return ( (unsigned int)( (unsigned long)name._GetSharedName() ) ) / 8;
|
|
}
|
|
|
|
Net* Cell::NetMap::_GetNextElement(Net* net) const
|
|
// ***********************************************
|
|
{
|
|
return net->_GetNextOfCellNetMap();
|
|
}
|
|
|
|
void Cell::NetMap::_SetNextElement(Net* net, Net* nextNet) const
|
|
// *************************************************************
|
|
{
|
|
net->_SetNextOfCellNetMap(nextNet);
|
|
}
|
|
|
|
|
|
// ****************************************************************************************************
|
|
// Cell::PinMap implementation
|
|
// ****************************************************************************************************
|
|
|
|
Cell::PinMap::PinMap()
|
|
// *******************
|
|
: Inherit()
|
|
{
|
|
}
|
|
|
|
Name Cell::PinMap::_GetKey(Pin* pin) const
|
|
// ***************************************
|
|
{
|
|
return pin->GetName();
|
|
}
|
|
|
|
unsigned Cell::PinMap::_GetHashValue(Name name) const
|
|
// **************************************************
|
|
{
|
|
return ( (unsigned int)( (unsigned long)name._GetSharedName() ) ) / 8;
|
|
}
|
|
|
|
Pin* Cell::PinMap::_GetNextElement(Pin* pin) const
|
|
// ***********************************************
|
|
{
|
|
return pin->_GetNextOfCellPinMap();
|
|
}
|
|
|
|
void Cell::PinMap::_SetNextElement(Pin* pin, Pin* nextPin) const
|
|
// *************************************************************
|
|
{
|
|
pin->_SetNextOfCellPinMap(nextPin);
|
|
}
|
|
|
|
|
|
// ****************************************************************************************************
|
|
// Cell::SliceMap implementation
|
|
// ****************************************************************************************************
|
|
|
|
Cell::SliceMap::SliceMap()
|
|
// ***********************
|
|
: Inherit()
|
|
{
|
|
}
|
|
|
|
const Layer* Cell::SliceMap::_GetKey(Slice* slice) const
|
|
// *****************************************************
|
|
{
|
|
return slice->GetLayer();
|
|
}
|
|
|
|
unsigned Cell::SliceMap::_GetHashValue(const Layer* layer) const
|
|
// *************************************************************
|
|
{
|
|
return ( (unsigned int)( (unsigned long)layer ) ) / 8;
|
|
}
|
|
|
|
Slice* Cell::SliceMap::_GetNextElement(Slice* slice) const
|
|
// *******************************************************
|
|
{
|
|
return slice->_GetNextOfCellSliceMap();
|
|
}
|
|
|
|
void Cell::SliceMap::_SetNextElement(Slice* slice, Slice* nextSlice) const
|
|
// ***********************************************************************
|
|
{
|
|
slice->_SetNextOfCellSliceMap(nextSlice);
|
|
};
|
|
|
|
|
|
|
|
// ****************************************************************************************************
|
|
// Cell::MarkerSet implementation
|
|
// ****************************************************************************************************
|
|
|
|
Cell::MarkerSet::MarkerSet()
|
|
// *************************
|
|
: Inherit()
|
|
{
|
|
}
|
|
|
|
unsigned Cell::MarkerSet::_GetHashValue(Marker* marker) const
|
|
// **********************************************************
|
|
{
|
|
return ( (unsigned int)( (unsigned long)marker ) ) / 8;
|
|
}
|
|
|
|
Marker* Cell::MarkerSet::_GetNextElement(Marker* marker) const
|
|
// ***********************************************************
|
|
{
|
|
return marker->_GetNextOfCellMarkerSet();
|
|
}
|
|
|
|
void Cell::MarkerSet::_SetNextElement(Marker* marker, Marker* nextMarker) const
|
|
// ****************************************************************************
|
|
{
|
|
marker->_SetNextOfCellMarkerSet(nextMarker);
|
|
}
|
|
|
|
|
|
|
|
// ****************************************************************************************************
|
|
// Cell::ViewSet implementation
|
|
// ****************************************************************************************************
|
|
|
|
Cell::ViewSet::ViewSet()
|
|
// *********************
|
|
: Inherit()
|
|
{
|
|
}
|
|
|
|
unsigned Cell::ViewSet::_GetHashValue(View* view) const
|
|
// ****************************************************
|
|
{
|
|
return ( (unsigned int)( (unsigned long)view ) ) / 8;
|
|
}
|
|
|
|
View* Cell::ViewSet::_GetNextElement(View* view) const
|
|
// ***************************************************
|
|
{
|
|
return view->_GetNextOfCellViewSet();
|
|
}
|
|
|
|
void Cell::ViewSet::_SetNextElement(View* view, View* nextView) const
|
|
// ******************************************************************
|
|
{
|
|
view->_SetNextOfCellViewSet(nextView);
|
|
}
|
|
|
|
|
|
|
|
// ****************************************************************************************************
|
|
// Cell::Builder declaration
|
|
// ****************************************************************************************************
|
|
|
|
Cell::Builder::Builder(const string& token)
|
|
// ****************************************
|
|
: Inherit(token),
|
|
_library(NULL),
|
|
_name(),
|
|
_xMin(0),
|
|
_yMin(0),
|
|
_xMax(0),
|
|
_yMax(0),
|
|
_isTerminal(0)
|
|
{
|
|
}
|
|
|
|
void Cell::Builder::Scan(InputFile& inputFile, char*& arguments)
|
|
// *************************************************************
|
|
{
|
|
DBo* owner = inputFile.GetOwner();
|
|
|
|
if (!is_a<DataBase*>(owner))
|
|
throw Error("Can't create Cell : bad owner");
|
|
|
|
Inherit::Scan(inputFile, arguments);
|
|
|
|
unsigned libraryId;
|
|
unsigned n;
|
|
|
|
int r = sscanf(arguments, "%u%s%lf%lf%lf%lf%u%n", &libraryId, _name,
|
|
&_xMin, &_yMin, &_xMax, &_yMax, &_isTerminal, &n);
|
|
|
|
if (r != 7)
|
|
throw Error("Can't create Cell : syntax error");
|
|
|
|
arguments = &arguments[n];
|
|
|
|
DBo* dbo = inputFile.GetDBo(libraryId);
|
|
if (!dbo || !is_a<Library*>(dbo))
|
|
throw Error("Can't create Cell : bad library");
|
|
|
|
_library = (Library*)dbo;
|
|
}
|
|
|
|
DBo* Cell::Builder::CreateDBo()
|
|
// ****************************
|
|
{
|
|
return Cell::Create(GetLibrary(), GetName());
|
|
}
|
|
|
|
Cell::Builder CELL_BUILDER("C");
|
|
|
|
} // End of Hurricane namespace.
|
|
|
|
// ****************************************************************************************************
|
|
// Copyright (c) BULL S.A. 2000-2004, All Rights Reserved
|
|
// ****************************************************************************************************
|