/**Function*************************************************************
Synopsis [Returns name of the object if the ID is known.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
char * Nm_ManFindNameById( Nm_Man_t * p, int ObjId )
{
Nm_Entry_t * pEntry;
if ( (pEntry = Nm_ManTableLookupId(p, ObjId)) )
return pEntry->Name;
return NULL;
}
/**Function*************************************************************
Synopsis [Adds an entry to two hash tables.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Nm_ManTableAdd( Nm_Man_t * p, Nm_Entry_t * pEntry )
{
Nm_Entry_t ** ppSpot, * pOther;
// resize the tables if needed
if ( p->nEntries > p->nBins * p->nSizeFactor )
Nm_ManResize( p );
// add the entry to the table Id->Name
assert( Nm_ManTableLookupId(p, pEntry->ObjId) == NULL );
ppSpot = p->pBinsI2N + Nm_HashNumber(pEntry->ObjId, p->nBins);
pEntry->pNextI2N = *ppSpot;
*ppSpot = pEntry;
// check if an entry with the same name already exists
if ( (pOther = Nm_ManTableLookupName(p, pEntry->Name, -1)) )
{
// entry with the same name already exists - add it to the ring
pEntry->pNameSake = pOther->pNameSake? pOther->pNameSake : pOther;
pOther->pNameSake = pEntry;
}
else
{
// entry with the same name does not exist - add it to the table
ppSpot = p->pBinsN2I + Nm_HashString(pEntry->Name, p->nBins);
pEntry->pNextN2I = *ppSpot;
*ppSpot = pEntry;
}
// report successfully added entry
p->nEntries++;
return 1;
}
/**Function*************************************************************
Synopsis [Finds a unique name for the node.]
Description [If the name exists, tries appending numbers to it until
it becomes unique. The name is not added to the table.]
SideEffects []
SeeAlso []
***********************************************************************/
char * Nm_ManCreateUniqueName( Nm_Man_t * p, int ObjId )
{
static char NameStr[1000];
Nm_Entry_t * pEntry;
int i;
if ( (pEntry = Nm_ManTableLookupId(p, ObjId)) )
return pEntry->Name;
sprintf( NameStr, "n%d", ObjId );
for ( i = 1; Nm_ManTableLookupName(p, NameStr, -1); i++ )
sprintf( NameStr, "n%d_%d", ObjId, i );
return NameStr;
}
/**Function*************************************************************
Synopsis [Creates a new entry in the name manager.]
Description [Returns 1 if the entry with the given object ID
already exists in the name manager.]
SideEffects []
SeeAlso []
***********************************************************************/
void Nm_ManDeleteIdName( Nm_Man_t * p, int ObjId )
{
Nm_Entry_t * pEntry;
pEntry = Nm_ManTableLookupId(p, ObjId);
if ( pEntry == NULL )
{
printf( "Nm_ManDeleteIdName(): This entry is not in the table.\n" );
return;
}
// remove entry from the table
Nm_ManTableDelete( p, ObjId );
}
/**Function*************************************************************
Synopsis [Deletes the entry from two hash tables.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Nm_ManTableDelete( Nm_Man_t * p, int ObjId )
{
Nm_Entry_t ** ppSpot, * pEntry, * pPrev;
int fRemoved;
p->nEntries--;
// remove the entry from the table Id->Name
assert( Nm_ManTableLookupId(p, ObjId) != NULL );
ppSpot = p->pBinsI2N + Nm_HashNumber(ObjId, p->nBins);
while ( (*ppSpot)->ObjId != (unsigned)ObjId )
ppSpot = &(*ppSpot)->pNextI2N;
pEntry = *ppSpot;
*ppSpot = (*ppSpot)->pNextI2N;
// remove the entry from the table Name->Id
ppSpot = p->pBinsN2I + Nm_HashString(pEntry->Name, p->nBins);
while ( *ppSpot && *ppSpot != pEntry )
ppSpot = &(*ppSpot)->pNextN2I;
// remember if we found this one in the list
fRemoved = (*ppSpot != NULL);
if ( *ppSpot )
{
assert( *ppSpot == pEntry );
*ppSpot = (*ppSpot)->pNextN2I;
}
// quit if this entry has no namesakes
if ( pEntry->pNameSake == NULL )
{
assert( fRemoved );
return 1;
}
// remove entry from the ring of namesakes
assert( pEntry->pNameSake != pEntry );
for ( pPrev = pEntry; pPrev->pNameSake != pEntry; pPrev = pPrev->pNameSake );
assert( !strcmp(pPrev->Name, pEntry->Name) );
assert( pPrev->pNameSake == pEntry );
if ( pEntry->pNameSake == pPrev ) // two entries in the ring
pPrev->pNameSake = NULL;
else
pPrev->pNameSake = pEntry->pNameSake;
// reinsert the ring back if we removed its connection with the list in the table
if ( fRemoved )
{
assert( pPrev->pNextN2I == NULL );
pPrev->pNextN2I = *ppSpot;
*ppSpot = pPrev;
}
return 1;
}
/**Function*************************************************************
Synopsis [Creates a new entry in the name manager.]
Description [Returns 1 if the entry with the given object ID
already exists in the name manager.]
SideEffects []
SeeAlso []
***********************************************************************/
char * Nm_ManStoreIdName( Nm_Man_t * p, int ObjId, int Type, char * pName, char * pSuffix )
{
Nm_Entry_t * pEntry;
int RetValue, nEntrySize;
// check if the object with this ID is already stored
if ( pEntry = Nm_ManTableLookupId(p, ObjId) )
{
printf( "Nm_ManStoreIdName(): Entry with the same ID already exists.\n" );
return NULL;
}
// create a new entry
nEntrySize = sizeof(Nm_Entry_t) + strlen(pName) + (pSuffix?strlen(pSuffix):0) + 1;
nEntrySize = (nEntrySize / 4 + ((nEntrySize % 4) > 0)) * 4;
pEntry = (Nm_Entry_t *)Extra_MmFlexEntryFetch( p->pMem, nEntrySize );
pEntry->pNextI2N = pEntry->pNextN2I = pEntry->pNameSake = NULL;
pEntry->ObjId = ObjId;
pEntry->Type = Type;
sprintf( pEntry->Name, "%s%s", pName, pSuffix? pSuffix : "" );
// add the entry to the hash table
RetValue = Nm_ManTableAdd( p, pEntry );
assert( RetValue == 1 );
return pEntry->Name;
}
