/**Function*************************************************************
Synopsis [Deletes the node.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Ivy_ObjDelete( Ivy_Man_t * p, Ivy_Obj_t * pObj, int fFreeTop )
{
assert( !Ivy_IsComplement(pObj) );
assert( Ivy_ObjRefs(pObj) == 0 || !fFreeTop );
// update node counters of the manager
p->nObjs[pObj->Type]--;
p->nDeleted++;
// remove connections
Ivy_ObjDisconnect( p, pObj );
// remove PIs/POs from the arrays
if ( Ivy_ObjIsPi(pObj) )
Vec_PtrRemove( p->vPis, pObj );
else if ( Ivy_ObjIsPo(pObj) )
Vec_PtrRemove( p->vPos, pObj );
else if ( p->fFanout && Ivy_ObjIsBuf(pObj) )
Vec_PtrRemove( p->vBufs, pObj );
// clean and recycle the entry
if ( fFreeTop )
{
// free the node
Vec_PtrWriteEntry( p->vObjs, pObj->Id, NULL );
Ivy_ManRecycleMemory( p, pObj );
}
else
{
int nRefsOld = pObj->nRefs;
Ivy_Obj_t * pFanout = pObj->pFanout;
Ivy_ObjClean( pObj );
pObj->pFanout = pFanout;
pObj->nRefs = nRefsOld;
}
}
/**Function*************************************************************
Synopsis [Deletes the node.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Aig_ObjDelete( Aig_Man_t * p, Aig_Obj_t * pObj )
{
assert( !Aig_IsComplement(pObj) );
assert( !Aig_ObjIsTerm(pObj) );
assert( Aig_ObjRefs(pObj) == 0 );
if ( p->pFanData && Aig_ObjIsBuf(pObj) )
Vec_PtrRemove( p->vBufs, pObj );
p->nObjs[pObj->Type]--;
Vec_PtrWriteEntry( p->vObjs, pObj->Id, NULL );
Aig_ManRecycleMemory( p, pObj );
}
/**Function*************************************************************
Synopsis [Inserts a new node in the order by levels.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Dar_BalancePushUniqueOrderByLevel( Vec_Ptr_t * vStore, Aig_Obj_t * pObj, int fExor )
{
Aig_Obj_t * pObj1, * pObj2;
int i;
if ( Vec_PtrPushUnique(vStore, pObj) )
{
if ( fExor )
Vec_PtrRemove(vStore, pObj);
return;
}
// find the p of the node
for ( i = vStore->nSize-1; i > 0; i-- )
{
pObj1 = (Aig_Obj_t *)vStore->pArray[i ];
pObj2 = (Aig_Obj_t *)vStore->pArray[i-1];
if ( Aig_ObjLevel(Aig_Regular(pObj1)) <= Aig_ObjLevel(Aig_Regular(pObj2)) )
break;
vStore->pArray[i ] = pObj2;
vStore->pArray[i-1] = pObj1;
}
}
/**Function*************************************************************
Synopsis [Detects constraints using structural methods.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Saig_ManDetectConstr( Aig_Man_t * p, int iOut, Vec_Ptr_t ** pvOuts, Vec_Ptr_t ** pvCons )
{
Vec_Ptr_t * vSuper, * vSuper2 = NULL, * vUnique;
Aig_Obj_t * pObj, * pObj2, * pFlop;
int i, nFlops, RetValue;
assert( iOut >= 0 && iOut < Saig_ManPoNum(p) );
*pvOuts = NULL;
*pvCons = NULL;
pObj = Aig_ObjChild0( Aig_ManCo(p, iOut) );
if ( Aig_IsComplement(pObj) || !Aig_ObjIsNode(pObj) )
{
printf( "The output is not an AND.\n" );
return 0;
}
vSuper = Saig_DetectConstrCollectSuper( pObj );
assert( Vec_PtrSize(vSuper) >= 2 );
nFlops = 0;
Vec_PtrForEachEntry( Aig_Obj_t *, vSuper, pObj, i )
nFlops += Saig_ObjIsLo( p, Aig_Regular(pObj) );
if ( nFlops == 0 )
{
printf( "There is no flop outputs.\n" );
Vec_PtrFree( vSuper );
return 0;
}
// try flops
vUnique = NULL;
Vec_PtrForEachEntry( Aig_Obj_t *, vSuper, pObj, i )
{
pFlop = Aig_Regular( pObj );
if ( !Saig_ObjIsLo(p, pFlop) )
continue;
pFlop = Saig_ObjLoToLi( p, pFlop );
pObj2 = Aig_ObjChild0( pFlop );
if ( !Aig_IsComplement(pObj2) || !Aig_ObjIsNode(Aig_Regular(pObj2)) )
continue;
vSuper2 = Saig_DetectConstrCollectSuper( Aig_Regular(pObj2) );
// every node in vSuper2 should appear in vSuper
vUnique = Saig_ManDetectConstrCheckCont( vSuper, vSuper2 );
if ( vUnique != NULL )
{
/// assert( !Aig_IsComplement(pObj) );
// assert( Vec_PtrFind( vSuper2, pObj ) >= 0 );
if ( Aig_IsComplement(pObj) )
{
printf( "Special flop input is complemented.\n" );
Vec_PtrFreeP( &vUnique );
Vec_PtrFree( vSuper2 );
break;
}
if ( Vec_PtrFind( vSuper2, pObj ) == -1 )
{
printf( "Cannot find special flop about the inputs of OR gate.\n" );
Vec_PtrFreeP( &vUnique );
Vec_PtrFree( vSuper2 );
break;
}
// remove the flop output
Vec_PtrRemove( vSuper2, pObj );
break;
}
Vec_PtrFree( vSuper2 );
}
