luke
/
abc
mirror of https://github.com/YosysHQ/abc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Changing the ordering of arguments in two iterators.

This commit is contained in:
Alan Mishchenko 2011-08-01 13:47:51 +07:00
parent 820a147ef1
commit 961f7532d7
16 changed files with 82 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/aig/aig/aig.h
View File

@ -419,20 +419,15 @@ static inline void Aig_ManRecycleMemory( Aig_Man_t * p, Aig_Obj_t * pEntry )
// iterator over all objects, including those currently not used
#define Aig_ManForEachObj( p, pObj, i ) \
Vec_PtrForEachEntry( Aig_Obj_t *, p->vObjs, pObj, i ) if ( (pObj) == NULL ) {} else
// iterator over the objects whose IDs are stored in an array
#define Aig_ManForEachObjVec( vIds, p, pObj, i ) \
for ( i = 0; i < Vec_IntSize(vIds) && (((pObj) = Aig_ManObj(p, Vec_IntEntry(vIds,i))), 1); i++ )
// iterator over all nodes
#define Aig_ManForEachNode( p, pObj, i ) \
Vec_PtrForEachEntry( Aig_Obj_t *, p->vObjs, pObj, i ) if ( (pObj) == NULL || !Aig_ObjIsNode(pObj) ) {} else
// iterator over all nodes
#define Aig_ManForEachExor( p, pObj, i ) \
Vec_PtrForEachEntry( Aig_Obj_t *, p->vObjs, pObj, i ) if ( (pObj) == NULL || !Aig_ObjIsExor(pObj) ) {} else
// iterator over the nodes whose IDs are stored in the array
#define Aig_ManForEachNodeVec( p, vIds, pObj, i ) \
for ( i = 0; i < Vec_IntSize(vIds) && ((pObj) = Aig_ManObj(p, Vec_IntEntry(vIds,i))); i++ )
// iterator over the nodes in the topological order
#define Aig_ManForEachNodeInOrder( p, pObj ) \
for ( assert(p->pOrderData), p->iPrev = 0, p->iNext = p->pOrderData[1]; \
p->iNext && (((pObj) = Aig_ManObj(p, p->iNext)), 1); \
p->iNext = p->pOrderData[2*p->iPrev+1] )
// these two procedures are only here for the use inside the iterator
static inline int Aig_ObjFanout0Int( Aig_Man_t * p, int ObjId ) { assert(ObjId < p->nFansAlloc); return p->pFanData[5*ObjId]; }

2
src/aig/aig/aigJust.c
View File

@ -259,7 +259,7 @@ void Aig_ManJustExperiment( Aig_Man_t * pAig )
pPack = Aig_ManPackStart( pAig );
vNodes = Aig_ManPackConstNodes( pPack );
// Aig_ManForEachPo( pAig, pObj, i )
Aig_ManForEachNodeVec( pAig, vNodes, pObj, i )
Aig_ManForEachObjVec( vNodes, pAig, pObj, i )
{
if ( pObj->fPhase ) // const 1
{

6
src/aig/dar/darCore.c
View File

@ -27,6 +27,12 @@ ABC_NAMESPACE_IMPL_START
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
// iterator over the nodes in the topological order
#define Aig_ManForEachNodeInOrder( p, pObj ) \
for ( assert(p->pOrderData), p->iPrev = 0, p->iNext = p->pOrderData[1]; \
p->iNext && (((pObj) = Aig_ManObj(p, p->iNext)), 1); \
p->iNext = p->pOrderData[2*p->iPrev+1] )
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////

8
src/aig/llb/llb1Group.c
View File

@ -318,19 +318,19 @@ Llb_Grp_t * Llb_ManGroupCreateFromCuts( Llb_Man_t * pMan, Vec_Int_t * vCut1, Vec
// mark Cut1
Aig_ManIncrementTravId( pMan->pAig );
Aig_ManForEachNodeVec( pMan->pAig, vCut1, pObj, i )
Aig_ManForEachObjVec( vCut1, pMan->pAig, pObj, i )
Aig_ObjSetTravIdCurrent( pMan->pAig, pObj );
// collect unmarked Cut2
Aig_ManForEachNodeVec( pMan->pAig, vCut2, pObj, i )
Aig_ManForEachObjVec( vCut2, pMan->pAig, pObj, i )
if ( !Aig_ObjIsTravIdCurrent( pMan->pAig, pObj ) )
Vec_PtrPush( p->vOuts, pObj );
// mark nodes reachable from Cut2
Aig_ManIncrementTravId( pMan->pAig );
Aig_ManForEachNodeVec( pMan->pAig, vCut2, pObj, i )
Aig_ManForEachObjVec( vCut2, pMan->pAig, pObj, i )
Llb_ManGroupMarkNodes_rec( pMan->pAig, pObj );
// collect marked Cut1
Aig_ManForEachNodeVec( pMan->pAig, vCut1, pObj, i )
Aig_ManForEachObjVec( vCut1, pMan->pAig, pObj, i )
if ( Aig_ObjIsTravIdCurrent( pMan->pAig, pObj ) )
Vec_PtrPush( p->vIns, pObj );

2
src/aig/llb/llb2Driver.c
View File

@ -172,7 +172,7 @@ DdManager * Llb_DriverLastPartition( Aig_Man_t * p, Vec_Int_t * vVarsNs, int Tim
bRes = Cudd_ReadOne(dd); Cudd_Ref( bRes );
// mark the duplicated flop inputs
Aig_ManForEachNodeVec( p, vVarsNs, pObj, i )
Aig_ManForEachObjVec( vVarsNs, p, pObj, i )
{
if ( !Saig_ObjIsLi(p, pObj) )
continue;

2
src/aig/llb/llb2Image.c
View File

@ -262,7 +262,7 @@ DdNode * Llb_ImgComputeCube( Aig_Man_t * pAig, Vec_Int_t * vNodeIds, DdManager *
int i, TimeStop;
TimeStop = dd->TimeStop; dd->TimeStop = 0;
bProd = Cudd_ReadOne(dd); Cudd_Ref( bProd );
Aig_ManForEachNodeVec( pAig, vNodeIds, pObj, i )
Aig_ManForEachObjVec( vNodeIds, pAig, pObj, i )
{
bProd = Cudd_bddAnd( dd, bTemp = bProd, Cudd_bddIthVar(dd, Aig_ObjId(pObj)) ); Cudd_Ref( bProd );
Cudd_RecursiveDeref( dd, bTemp );

2
src/aig/llb/llb4Nonlin.c
View File

@ -340,7 +340,7 @@ Vec_Int_t * Llb_Nonlin4CreateOrder( Aig_Man_t * pAig )
// mark internal nodes to be used
Aig_ManCleanMarkA( pAig );
vNodes = Llb_Nonlin4CollectHighRefNodes( pAig, 4 );
Aig_ManForEachNodeVec( pAig, vNodes, pObj, i )
Aig_ManForEachObjVec( vNodes, pAig, pObj, i )
pObj->fMarkA = 1;
printf( "Techmapping added %d pivots.\n", Vec_IntSize(vNodes) );
*/

6
src/aig/saig/saigAbsCba.c
View File

@ -337,7 +337,7 @@ Aig_Man_t * Saig_ManCbaUnrollWithCex( Aig_Man_t * pAig, Abc_Cex_t * pCex, int nI
// collect nodes starting from the roots
Aig_ManIncrementTravId( pAig );
vRoots = Vec_VecEntryInt( vFrameCos, f );
Aig_ManForEachNodeVec( pAig, vRoots, pObj, i )
Aig_ManForEachObjVec( vRoots, pAig, pObj, i )
Saig_ManCbaUnrollCollect_rec( pAig, pObj,
Vec_VecEntryInt(vFrameObjs, f),
(Vec_Int_t *)(f ? Vec_VecEntry(vFrameCos, f-1) : NULL) );
@ -355,7 +355,7 @@ Aig_Man_t * Saig_ManCbaUnrollWithCex( Aig_Man_t * pAig, Abc_Cex_t * pCex, int nI
{
// construct
vObjs = Vec_VecEntryInt( vFrameObjs, f );
Aig_ManForEachNodeVec( pAig, vObjs, pObj, i )
Aig_ManForEachObjVec( vObjs, pAig, pObj, i )
{
if ( Aig_ObjIsNode(pObj) )
pObj->pData = Aig_And( pFrames, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj) );
@ -382,7 +382,7 @@ Aig_Man_t * Saig_ManCbaUnrollWithCex( Aig_Man_t * pAig, Abc_Cex_t * pCex, int nI
break;
// transfer
vRoots = Vec_VecEntryInt( vFrameCos, f );
Aig_ManForEachNodeVec( pAig, vRoots, pObj, i )
Aig_ManForEachObjVec( vRoots, pAig, pObj, i )
{
Saig_ObjLiToLo( pAig, pObj )->pData = pObj->pData;
if ( *pvReg2Frame )

6
src/aig/saig/saigAbsPba.c
View File

@ -91,7 +91,7 @@ Aig_Man_t * Saig_ManUnrollForPba( Aig_Man_t * pAig, int nFrames )
Vec_IntPush( vRoots, Aig_ObjId(pObj) );
// collect nodes starting from the roots
Aig_ManIncrementTravId( pAig );
Aig_ManForEachNodeVec( pAig, vRoots, pObj, i )
Aig_ManForEachObjVec( vRoots, pAig, pObj, i )
Saig_ManUnrollForPba_rec( pAig, pObj,
Vec_VecEntryInt( vFrameObjs, f ),
(Vec_Int_t *)(f ? Vec_VecEntry(vFrameCos, f-1) : NULL) );
@ -112,7 +112,7 @@ Aig_Man_t * Saig_ManUnrollForPba( Aig_Man_t * pAig, int nFrames )
{
// construct
vObjs = Vec_VecEntryInt( vFrameObjs, f );
Aig_ManForEachNodeVec( pAig, vObjs, pObj, i )
Aig_ManForEachObjVec( vObjs, pAig, pObj, i )
{
if ( Aig_ObjIsNode(pObj) )
pObj->pData = Aig_And( pFrames, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj) );
@ -132,7 +132,7 @@ Aig_Man_t * Saig_ManUnrollForPba( Aig_Man_t * pAig, int nFrames )
if ( f == nFrames - 1 )
break;
vRoots = Vec_VecEntryInt( vFrameCos, f );
Aig_ManForEachNodeVec( pAig, vRoots, pObj, i )
Aig_ManForEachObjVec( vRoots, pAig, pObj, i )
{
if ( Saig_ObjIsLi(pAig, pObj) )
{

30
src/aig/saig/saigCexMin.c
View File

@ -321,6 +321,36 @@ Abc_Cex_t * Saig_ManCexMinPerform( Aig_Man_t * pAig, Abc_Cex_t * pCex )
return pCexMin;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Saig_ManCexMinGetCos( Aig_Man_t * pAig, Abc_Cex_t * pCex, Vec_Vec_t * vFrameCis, int f, Vec_Int_t * vTemp )
{
Vec_Int_t * vFrameCisOne;
Aig_Obj_t * pObj;
int i;
Vec_IntClear( vTemp );
if ( f == Vec_VecSize(vFrameCis) - 1 )
{
pObj = Aig_ManPo( pAig, pCex->iPo );
Vec_IntPush( vTemp, Aig_ObjId(pObj) );
return;
}
vFrameCisOne = Vec_VecEntryInt( vFrameCis, f+1 );
Aig_ManForEachObjVec( vFrameCisOne, pAig, pObj, i )
if ( Saig_ObjIsLo(pAig, pObj) )
Vec_IntPush( vTemp, Aig_ObjId( Saig_ObjLoToLi(pAig, pObj) ) );
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////

2
src/aig/saig/saigDup.c
View File

@ -112,7 +112,7 @@ Aig_Man_t * Saig_ManCreateEquivMiter( Aig_Man_t * pAig, Vec_Int_t * vPairs )
pObj->pData = Aig_And( pAigNew, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj) );
// create POs
assert( Vec_IntSize(vPairs) % 2 == 0 );
Aig_ManForEachNodeVec( pAig, vPairs, pObj, i )
Aig_ManForEachObjVec( vPairs, pAig, pObj, i )
{
pObj2 = Aig_ManObj( pAig, Vec_IntEntry(vPairs, ++i) );
pMiter = Aig_Exor( pAigNew, (Aig_Obj_t *)pObj->pData, (Aig_Obj_t *)pObj2->pData );

6
src/aig/saig/saigRefSat.c
View File

@ -287,7 +287,7 @@ Aig_Man_t * Saig_ManUnrollWithCex( Aig_Man_t * pAig, Abc_Cex_t * pCex, int nInpu
// collect nodes starting from the roots
Aig_ManIncrementTravId( pAig );
vRoots = Vec_VecEntryInt( vFrameCos, f );
Aig_ManForEachNodeVec( pAig, vRoots, pObj, i )
Aig_ManForEachObjVec( vRoots, pAig, pObj, i )
Saig_ManUnrollCollect_rec( pAig, pObj,
Vec_VecEntryInt(vFrameObjs, f),
(Vec_Int_t *)(f ? Vec_VecEntry(vFrameCos, f-1) : NULL) );
@ -305,7 +305,7 @@ Aig_Man_t * Saig_ManUnrollWithCex( Aig_Man_t * pAig, Abc_Cex_t * pCex, int nInpu
{
// construct
vObjs = Vec_VecEntryInt( vFrameObjs, f );
Aig_ManForEachNodeVec( pAig, vObjs, pObj, i )
Aig_ManForEachObjVec( vObjs, pAig, pObj, i )
{
if ( Aig_ObjIsNode(pObj) )
pObj->pData = Aig_And( pFrames, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj) );
@ -332,7 +332,7 @@ Aig_Man_t * Saig_ManUnrollWithCex( Aig_Man_t * pAig, Abc_Cex_t * pCex, int nInpu
break;
// transfer
vRoots = Vec_VecEntryInt( vFrameCos, f );
Aig_ManForEachNodeVec( pAig, vRoots, pObj, i )
Aig_ManForEachObjVec( vRoots, pAig, pObj, i )
Saig_ObjLiToLo( pAig, pObj )->pData = pObj->pData;
}
// create output

2
src/base/abc/abc.h
View File

@ -451,7 +451,7 @@ static inline void Abc_ObjSetMvVar( Abc_Obj_t * pObj, void * pV) { Vec_At
#define Abc_NtkForEachObj( pNtk, pObj, i ) \
for ( i = 0; (i < Vec_PtrSize((pNtk)->vObjs)) && (((pObj) = Abc_NtkObj(pNtk, i)), 1); i++ ) \
if ( (pObj) == NULL ) {} else
#define Abc_NtkForEachObjVec( pNtk, vIds, pObj, i ) \
#define Abc_NtkForEachObjVec( vIds, pNtk, pObj, i ) \
for ( i = 0; i < Vec_IntSize(vIds) && (((pObj) = Abc_NtkObj(pNtk, Vec_IntEntry(vIds,i))), 1); i++ ) \
if ( (pObj) == NULL ) {} else
#define Abc_NtkForEachNet( pNtk, pNet, i ) \

18
src/base/abci/abcMffc.c
View File

@ -455,14 +455,14 @@ void Abc_NktMffcPrintInt( char * pFileName, Abc_Ntk_t * pNtk, Vec_Int_t * vRoots
pFile = fopen( pFileName, "wb" );
fprintf( pFile, ".model %s_part\n", pNtk->pName );
fprintf( pFile, ".inputs" );
Abc_NtkForEachObjVec( pNtk, vLeaves, pObj, i )
Abc_NtkForEachObjVec( vLeaves, pNtk, pObj, i )
fprintf( pFile, " %s", Abc_ObjName(pObj) );
fprintf( pFile, "\n" );
fprintf( pFile, ".outputs" );
Abc_NtkForEachObjVec( pNtk, vRoots, pObj, i )
Abc_NtkForEachObjVec( vRoots, pNtk, pObj, i )
fprintf( pFile, " %s", Abc_ObjName(pObj) );
fprintf( pFile, "\n" );
Abc_NtkForEachObjVec( pNtk, vNodes, pObj, i )
Abc_NtkForEachObjVec( vNodes, pNtk, pObj, i )
{
fprintf( pFile, ".names" );
Abc_ObjForEachFanin( pObj, pFanin, k )
@ -757,12 +757,12 @@ void Abc_NktMffCollectLeafRootInt( Abc_Ntk_t * pNtk, Vec_Int_t * vNodes, Vec_Int
Abc_Obj_t * pObj, * pNext;
int i, k;
// mark
Abc_NtkForEachObjVec( pNtk, vNodes, pObj, i )
Abc_NtkForEachObjVec( vNodes, pNtk, pObj, i )
pObj->fMarkA = 1;
// collect leaves
Vec_IntClear( vLeaves );
Abc_NtkIncrementTravId( pNtk );
Abc_NtkForEachObjVec( pNtk, vNodes, pObj, i )
Abc_NtkForEachObjVec( vNodes, pNtk, pObj, i )
Abc_ObjForEachFanin( pObj, pNext, k )
{
if ( pNext->fMarkA || Abc_NodeIsTravIdCurrent(pNext) )
@ -774,7 +774,7 @@ void Abc_NktMffCollectLeafRootInt( Abc_Ntk_t * pNtk, Vec_Int_t * vNodes, Vec_Int
if ( vRoots )
{
Vec_IntClear( vRoots );
Abc_NtkForEachObjVec( pNtk, vNodes, pObj, i )
Abc_NtkForEachObjVec( vNodes, pNtk, pObj, i )
{
Abc_ObjForEachFanout( pObj, pNext, k )
if ( !pNext->fMarkA )
@ -785,7 +785,7 @@ void Abc_NktMffCollectLeafRootInt( Abc_Ntk_t * pNtk, Vec_Int_t * vNodes, Vec_Int
}
}
// unmark
Abc_NtkForEachObjVec( pNtk, vNodes, pObj, i )
Abc_NtkForEachObjVec( vNodes, pNtk, pObj, i )
pObj->fMarkA = 0;
}
@ -1051,7 +1051,7 @@ Abc_Obj_t * Abc_NktMffcFindBest( Abc_Ntk_t * pNtk, Vec_Int_t * vMarks, Vec_Int_t
int i, Volume;
// collect the fanouts of the fanins
vOuts = Vec_IntAlloc( 100 );
Abc_NtkForEachObjVec( pNtk, vIns, pObj, i )
Abc_NtkForEachObjVec( vIns, pNtk, pObj, i )
{
vOuts2 = (Vec_Int_t *)Vec_PtrEntry( vFanouts, Abc_ObjId(pObj) );
if ( Vec_IntSize(vOuts2) > 16 )
@ -1060,7 +1060,7 @@ Abc_Obj_t * Abc_NktMffcFindBest( Abc_Ntk_t * pNtk, Vec_Int_t * vMarks, Vec_Int_t
Vec_IntFree( vTemp );
}
// check the pairs
Abc_NtkForEachObjVec( pNtk, vOuts, pPivot2, i )
Abc_NtkForEachObjVec( vOuts, pNtk, pPivot2, i )
{
if ( Vec_IntEntry(vMarks, Abc_ObjId(pPivot2)) == 0 )
continue;

2
src/sat/pdr/pdrSat.c
View File

@ -219,7 +219,7 @@ void Pdr_ManCollectValues( Pdr_Man_t * p, int k, Vec_Int_t * vObjIds, Vec_Int_t
int iVar, i;
Vec_IntClear( vValues );
pSat = Pdr_ManSolver(p, k);
Aig_ManForEachNodeVec( p->pAig, vObjIds, pObj, i )
Aig_ManForEachObjVec( vObjIds, p->pAig, pObj, i )
{
iVar = Pdr_ObjSatVar( p, k, pObj ); assert( iVar >= 0 );
Vec_IntPush( vValues, sat_solver_var_value(pSat, iVar) );

28
src/sat/pdr/pdrTsim.c
View File

@ -112,7 +112,7 @@ void Pdr_ManCollectCone( Aig_Man_t * pAig, Vec_Int_t * vCoObjs, Vec_Int_t * vCiO
Vec_IntClear( vNodes );
Aig_ManIncrementTravId( pAig );
Aig_ObjSetTravIdCurrent( pAig, Aig_ManConst1(pAig) );
Aig_ManForEachNodeVec( pAig, vCoObjs, pObj, i )
Aig_ManForEachObjVec( vCoObjs, pAig, pObj, i )
Pdr_ManCollectCone_rec( pAig, pObj, vCiObjs, vNodes );
}
@ -166,20 +166,20 @@ int Pdr_ManSimDataInit( Aig_Man_t * pAig,
int i;
// set the CI values
Pdr_ManSimInfoSet( pAig, Aig_ManConst1(pAig), PDR_ONE );
Aig_ManForEachNodeVec( pAig, vCiObjs, pObj, i )
Aig_ManForEachObjVec( vCiObjs, pAig, pObj, i )
Pdr_ManSimInfoSet( pAig, pObj, (Vec_IntEntry(vCiVals, i)?PDR_ONE:PDR_ZER) );
// set the FOs to remove
if ( vCi2Rem != NULL )
Aig_ManForEachNodeVec( pAig, vCi2Rem, pObj, i )
Aig_ManForEachObjVec( vCi2Rem, pAig, pObj, i )
Pdr_ManSimInfoSet( pAig, pObj, PDR_UND );
// perform ternary simulation
Aig_ManForEachNodeVec( pAig, vNodes, pObj, i )
Aig_ManForEachObjVec( vNodes, pAig, pObj, i )
Pdr_ManExtendOneEval( pAig, pObj );
// transfer results to the output
Aig_ManForEachNodeVec( pAig, vCoObjs, pObj, i )
Aig_ManForEachObjVec( vCoObjs, pAig, pObj, i )
Pdr_ManExtendOneEval( pAig, pObj );
// check the results
Aig_ManForEachNodeVec( pAig, vCoObjs, pObj, i )
Aig_ManForEachObjVec( vCoObjs, pAig, pObj, i )
if ( Pdr_ManSimInfoGet( pAig, pObj ) != (Vec_IntEntry(vCoVals, i)?PDR_ONE:PDR_ZER) )
return 0;
return 1;
@ -212,7 +212,7 @@ int Pdr_ManExtendOne( Aig_Man_t * pAig, Aig_Obj_t * pObj, Vec_Int_t * vUndo, Vec
// traverse
Vec_IntClear( vVis );
Vec_IntPush( vVis, Aig_ObjId(pObj) );
Aig_ManForEachNodeVec( pAig, vVis, pObj, i )
Aig_ManForEachObjVec( vVis, pAig, pObj, i )
{
Aig_ObjForEachFanout( pAig, pObj, pFanout, iFanout, k )
{
@ -252,7 +252,7 @@ void Pdr_ManExtendUndo( Aig_Man_t * pAig, Vec_Int_t * vUndo )
{
Aig_Obj_t * pObj;
int i, Value;
Aig_ManForEachNodeVec( pAig, vUndo, pObj, i )
Aig_ManForEachObjVec( vUndo, pAig, pObj, i )
{
Value = Vec_IntEntry(vUndo, ++i);
assert( Pdr_ManSimInfoGet(pAig, pObj) == PDR_UND );
@ -277,7 +277,7 @@ void Pdr_ManDeriveResult( Aig_Man_t * pAig, Vec_Int_t * vCiObjs, Vec_Int_t * vCi
int i, Lit;
// mark removed flop outputs
Aig_ManIncrementTravId( pAig );
Aig_ManForEachNodeVec( pAig, vCi2Rem, pObj, i )
Aig_ManForEachObjVec( vCi2Rem, pAig, pObj, i )
{
assert( Saig_ObjIsLo( pAig, pObj ) );
Aig_ObjSetTravIdCurrent(pAig, pObj);
@ -285,7 +285,7 @@ void Pdr_ManDeriveResult( Aig_Man_t * pAig, Vec_Int_t * vCiObjs, Vec_Int_t * vCi
// collect flop outputs that are not marked
Vec_IntClear( vRes );
Vec_IntClear( vPiLits );
Aig_ManForEachNodeVec( pAig, vCiObjs, pObj, i )
Aig_ManForEachObjVec( vCiObjs, pAig, pObj, i )
{
if ( Saig_ObjIsPi(pAig, pObj) )
{
@ -322,10 +322,10 @@ void Pdr_ManPrintCex( Aig_Man_t * pAig, Vec_Int_t * vCiObjs, Vec_Int_t * vCiVals
for ( i = 0; i < Aig_ManPiNum(pAig); i++ )
pBuff[i] = '-';
pBuff[i] = 0;
Aig_ManForEachNodeVec( pAig, vCiObjs, pObj, i )
Aig_ManForEachObjVec( vCiObjs, pAig, pObj, i )
pBuff[Aig_ObjPioNum(pObj)] = (Vec_IntEntry(vCiVals, i)? '1':'0');
if ( vCi2Rem )
Aig_ManForEachNodeVec( pAig, vCi2Rem, pObj, i )
Aig_ManForEachObjVec( vCi2Rem, pAig, pObj, i )
pBuff[Aig_ObjPioNum(pObj)] = 'x';
printf( "%s\n", pBuff );
ABC_FREE( pBuff );
@ -402,7 +402,7 @@ Pdr_ManPrintCex( p->pAig, vCiObjs, vCiVals, NULL );
// try removing high-priority flops
Vec_IntClear( vCi2Rem );
Aig_ManForEachNodeVec( p->pAig, vCiObjs, pObj, i )
Aig_ManForEachObjVec( vCiObjs, p->pAig, pObj, i )
{
if ( !Saig_ObjIsLo( p->pAig, pObj ) )
continue;
@ -416,7 +416,7 @@ Pdr_ManPrintCex( p->pAig, vCiObjs, vCiVals, NULL );
Pdr_ManExtendUndo( p->pAig, vUndo );
}
// try removing low-priority flops
Aig_ManForEachNodeVec( p->pAig, vCiObjs, pObj, i )
Aig_ManForEachObjVec( vCiObjs, p->pAig, pObj, i )
{
if ( !Saig_ObjIsLo( p->pAig, pObj ) )
continue;