271 lines
8.8 KiB
C++
271 lines
8.8 KiB
C++
// -*- C++ -*-
|
|
//
|
|
// This file is part of the Coriolis Software.
|
|
// Copyright (c) UPMC 2015-2018, All Rights Reserved
|
|
//
|
|
// +-----------------------------------------------------------------+
|
|
// | C O R I O L I S |
|
|
// | Alliance / Hurricane Interface |
|
|
// | |
|
|
// | Author : Jean-Paul CHAPUT |
|
|
// | E-mail : Jean-Paul.Chaput@lip6.fr |
|
|
// | =============================================================== |
|
|
// | C++ Module : "./CellsModel.cpp" |
|
|
// +-----------------------------------------------------------------+
|
|
|
|
|
|
#include <iostream>
|
|
#include <algorithm>
|
|
#include <QFont>
|
|
#include <QApplication>
|
|
#include "vlsisapd/utilities/Path.h"
|
|
#include "hurricane/Error.h"
|
|
#include "hurricane/Cells.h"
|
|
#include "hurricane/Library.h"
|
|
#include "hurricane/viewer/Graphics.h"
|
|
#include "crlcore/AllianceFramework.h"
|
|
#include "crlcore/Catalog.h"
|
|
#include "crlcore/AcmSigda.h"
|
|
#include "crlcore/Ispd05Bookshelf.h"
|
|
#include "crlcore/Blif.h"
|
|
#include "crlcore/Iccad04Lefdef.h"
|
|
#include "crlcore/CellsModel.h"
|
|
|
|
|
|
namespace CRL {
|
|
|
|
using namespace std;
|
|
using Hurricane::ForEachIterator;
|
|
using Hurricane::Error;
|
|
using Hurricane::Library;
|
|
using Hurricane::Graphics;
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "CellsModel".
|
|
|
|
|
|
ALibraryMap CellsModel::_libraries;
|
|
|
|
|
|
void CellsModel::deleteStaticDatas ()
|
|
{
|
|
for ( auto ilibrary : _libraries ) {
|
|
for ( auto cellDatas : ilibrary.second ) {
|
|
delete cellDatas;
|
|
}
|
|
}
|
|
_libraries.clear();
|
|
}
|
|
|
|
|
|
CellsModel::CellsModel ( QObject* parent )
|
|
: QAbstractTableModel(parent)
|
|
, _ilibrary (_libraries.end())
|
|
{
|
|
if (_libraries.empty()) {
|
|
_ilibrary = _libraries.insert( make_pair((const AllianceLibrary*)NULL,vector<CellDatas*>()) ).first;
|
|
}
|
|
|
|
CellLoaders* loaders = CellLoaders::get();
|
|
if (loaders->empty()) {
|
|
loaders->addLoader( new CellLoader("vbe"
|
|
, "VHDL Behavioral"
|
|
, CellLoader::Native
|
|
, Catalog::State::Logical ) );
|
|
loaders->addLoader( new CellLoader("vst"
|
|
, "VHDL Structural"
|
|
, CellLoader::Native
|
|
, Catalog::State::Logical ) );
|
|
loaders->addLoader( new CellLoader("vhd"
|
|
, "VHDL Structural (IEEE)"
|
|
, CellLoader::Native
|
|
, Catalog::State::Logical ) );
|
|
loaders->addLoader( new CellLoader("vhdl"
|
|
, "VHDL Structural (IEEE)"
|
|
, CellLoader::Native
|
|
, Catalog::State::Logical ) );
|
|
loaders->addLoader( new CellLoader("ap"
|
|
, "Alliance Physical"
|
|
, CellLoader::Native
|
|
, Catalog::State::Physical) );
|
|
loaders->addLoader( new CellLoader("bench"
|
|
, "ACM/SIGDA (aka MCNC)"
|
|
, CellLoader::Importer
|
|
, Catalog::State::Logical
|
|
, std::bind( &AcmSigda::load, placeholders::_1 ) ) );
|
|
loaders->addLoader( new CellLoader("aux"
|
|
, "ISPD'05 (Bookshelf)"
|
|
, CellLoader::Importer
|
|
, Catalog::State::Logical|Catalog::State::Physical
|
|
, std::bind( &Ispd05::load, placeholders::_1 ) ) );
|
|
loaders->addLoader( new CellLoader("blif"
|
|
, "BLIF (Yosys/ABC)"
|
|
, CellLoader::Importer|CellLoader::MultiCell
|
|
, Catalog::State::Logical
|
|
, std::bind( &Blif::load, placeholders::_1, true ) ) );
|
|
}
|
|
}
|
|
|
|
|
|
CellsModel::~CellsModel ()
|
|
{ }
|
|
|
|
|
|
QVariant CellsModel::data ( const QModelIndex& index, int role ) const
|
|
{
|
|
static QFont nameFont = Graphics::getFixedFont( QFont::Bold );
|
|
static QFont valueFont = Graphics::getFixedFont( QFont::Normal, false );
|
|
static QFont loadedFont = Graphics::getFixedFont( QFont::Normal, true );
|
|
|
|
if (role == Qt::FontRole) {
|
|
if (index.column() == 1) return valueFont;
|
|
|
|
const Catalog::State* state = getCellDatas(index.row())->getState();
|
|
if (state and state->isInMemory() )
|
|
return loadedFont;
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
if ( (not getLibrary()) or (not index.isValid()) ) return QVariant();
|
|
|
|
if (role == Qt::DisplayRole) {
|
|
if (index.column() == 0) return getCellDatas(index.row())->getName().c_str();
|
|
if (index.column() == 1) {
|
|
string s;
|
|
const Catalog::State* state = getCellDatas(index.row())->getState();
|
|
|
|
if (state) s = getString(state);
|
|
else s = ">>>>>>";
|
|
s += (getCellDatas(index.row())->isInMemory()) ? "M" : "-";
|
|
|
|
return s.c_str();
|
|
}
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
|
|
QVariant CellsModel::headerData ( int section
|
|
, Qt::Orientation orientation
|
|
, int role ) const
|
|
{
|
|
if (orientation == Qt::Vertical) return QVariant();
|
|
|
|
static QFont headerFont = Graphics::getFixedFont( QFont::Bold, false, false, +0 );
|
|
|
|
if (role == Qt::FontRole ) return headerFont;
|
|
if (role != Qt::DisplayRole) return QVariant();
|
|
|
|
switch ( section ) {
|
|
case 0: return QVariant("Name");
|
|
case 1: return QVariant("State");
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
|
|
Qt::ItemFlags CellsModel::flags ( const QModelIndex& index ) const
|
|
{
|
|
Qt::ItemFlags flags = QAbstractTableModel::flags(index);
|
|
|
|
//if (index.isValid() and (getCellDatas(index.row())->getState()->isInMemory() ) )
|
|
// return Qt::NoItemFlags;
|
|
|
|
return flags;
|
|
}
|
|
|
|
|
|
int CellsModel::rowCount ( const QModelIndex& parent ) const
|
|
{ return getCellsDatas().size(); }
|
|
|
|
|
|
int CellsModel::columnCount ( const QModelIndex& parent ) const
|
|
{ return 2; }
|
|
|
|
|
|
CellDatas* CellsModel::getCellDatas ( int row ) const
|
|
{
|
|
if (row >= (int)getCellsDatas().size()) return NULL;
|
|
return const_cast<CellDatas*>( getCellsDatas()[row] );
|
|
}
|
|
|
|
|
|
void CellsModel::emitDataChanged ( const QModelIndex& index )
|
|
{
|
|
emit layoutAboutToBeChanged();
|
|
emit dataChanged( index, index );
|
|
emit layoutChanged();
|
|
}
|
|
|
|
|
|
void CellsModel::updateLibrary ()
|
|
{
|
|
const AllianceLibrary* library = getLibrary();
|
|
_ilibrary = _libraries.end();
|
|
|
|
setLibrary( library );
|
|
}
|
|
|
|
|
|
void CellsModel::setLibrary ( const AllianceLibrary* library )
|
|
{
|
|
if (getLibrary() == library) return;
|
|
|
|
_ilibrary = _libraries.find( (const AllianceLibrary*)library );
|
|
if (_ilibrary == _libraries.end()) {
|
|
_ilibrary = _libraries.insert( make_pair(library,vector<CellDatas*>()) ).first;
|
|
}
|
|
|
|
emit layoutAboutToBeChanged();
|
|
|
|
if (not getLibrary()) return;
|
|
|
|
Catalog* catalog = AllianceFramework::get()->getCatalog();
|
|
CellLoaders* loaders = CellLoaders::get();
|
|
|
|
getCellsDatas().clear();
|
|
forEach ( Cell*, icell, library->getLibrary()->getCells() ) {
|
|
CellDatas* datas = new CellDatas(*icell);
|
|
getCellsDatas().push_back( datas );
|
|
}
|
|
std::sort( getCellsDatas().begin(), getCellsDatas().end(), LessCellDatas );
|
|
|
|
Utilities::Path libraryPath ( getString(getLibrary()->getPath()) );
|
|
CellDatas::setLibraryPath( libraryPath );
|
|
|
|
vector<Utilities::Path> cellFiles = libraryPath.listdir();
|
|
for ( Utilities::Path cellFile : cellFiles ) {
|
|
const CellLoader* loader = loaders->getLoader( cellFile.ext() );
|
|
if (not loader) continue;
|
|
|
|
bool added = false;
|
|
string cellName = cellFile.basename("."+cellFile.ext()).toString();
|
|
CellDatas* key = new CellDatas( cellName );
|
|
|
|
auto idatas = lower_bound( getCellsDatas().begin(), getCellsDatas().end(), key, LessCellDatas );
|
|
|
|
if ( (idatas == getCellsDatas().end())
|
|
or ((*idatas)->getName() != cellName ) ) {
|
|
getCellsDatas().push_back( key );
|
|
key->setState( catalog->getState(cellName) );
|
|
|
|
added = true;
|
|
} else {
|
|
delete key;
|
|
key = *idatas;
|
|
}
|
|
|
|
key->setFlags( loader->getFlags() & CellLoaders::lmask() );
|
|
|
|
if (added) std::sort( getCellsDatas().begin(), getCellsDatas().end(), LessCellDatas );
|
|
}
|
|
|
|
emit layoutChanged();
|
|
}
|
|
|
|
|
|
} // CRL namespace.
|