summaryrefslogtreecommitdiffstats
path: root/src/aig/aig
diff options
context:
space:
mode:
authorAlan Mishchenko <alanmi@berkeley.edu>2012-03-09 19:50:18 -0800
committerAlan Mishchenko <alanmi@berkeley.edu>2012-03-09 19:50:18 -0800
commitc46c957a0721004eb21c5f3d3f316ba1c8ab8df1 (patch)
treeede7a13119d06c192e7da95992d503107d2f1651 /src/aig/aig
parent2c8f1a67ec9295450a72fc27cbb3ed1177945734 (diff)
downloadabc-c46c957a0721004eb21c5f3d3f316ba1c8ab8df1.tar.gz
abc-c46c957a0721004eb21c5f3d3f316ba1c8ab8df1.tar.bz2
abc-c46c957a0721004eb21c5f3d3f316ba1c8ab8df1.zip
Renamed Aig_ObjIsPi/Po to be ...Ci/Co and Aig_Man(Pi/Po)Num to be ...(Ci/Co)...
Diffstat (limited to 'src/aig/aig')
-rw-r--r--src/aig/aig/aig.h56
-rw-r--r--src/aig/aig/aigCheck.c8
-rw-r--r--src/aig/aig/aigDfs.c34
-rw-r--r--src/aig/aig/aigDoms.c16
-rw-r--r--src/aig/aig/aigDup.c72
-rw-r--r--src/aig/aig/aigFact.c22
-rw-r--r--src/aig/aig/aigInter.c26
-rw-r--r--src/aig/aig/aigJust.c12
-rw-r--r--src/aig/aig/aigMan.c62
-rw-r--r--src/aig/aig/aigMffc.c10
-rw-r--r--src/aig/aig/aigObj.c36
-rw-r--r--src/aig/aig/aigOper.c6
-rw-r--r--src/aig/aig/aigPack.c6
-rw-r--r--src/aig/aig/aigPart.c74
-rw-r--r--src/aig/aig/aigPartReg.c30
-rw-r--r--src/aig/aig/aigPartSat.c12
-rw-r--r--src/aig/aig/aigRepar.c18
-rw-r--r--src/aig/aig/aigRepr.c2
-rw-r--r--src/aig/aig/aigRet.c8
-rw-r--r--src/aig/aig/aigRetF.c2
-rw-r--r--src/aig/aig/aigScl.c54
-rw-r--r--src/aig/aig/aigShow.c2
-rw-r--r--src/aig/aig/aigSplit.c6
-rw-r--r--src/aig/aig/aigTsim.c2
-rw-r--r--src/aig/aig/aigUtil.c36
-rw-r--r--src/aig/aig/aigWin.c2
26 files changed, 307 insertions, 307 deletions
diff --git a/src/aig/aig/aig.h b/src/aig/aig/aig.h
index 9d4a877b..4c437b8c 100644
--- a/src/aig/aig/aig.h
+++ b/src/aig/aig/aig.h
@@ -58,8 +58,8 @@ typedef struct Aig_MmStep_t_ Aig_MmStep_t;
typedef enum {
AIG_OBJ_NONE, // 0: non-existent object
AIG_OBJ_CONST1, // 1: constant 1
- AIG_OBJ_PI, // 2: primary input
- AIG_OBJ_PO, // 3: primary output
+ AIG_OBJ_CI, // 2: combinational input
+ AIG_OBJ_CO, // 3: combinational output
AIG_OBJ_BUF, // 4: buffer node
AIG_OBJ_AND, // 5: AND node
AIG_OBJ_EXOR, // 6: EXOR node
@@ -98,8 +98,8 @@ struct Aig_Man_t_
char * pName; // the design name
char * pSpec; // the input file name
// AIG nodes
- Vec_Ptr_t * vPis; // the array of PIs
- Vec_Ptr_t * vPos; // the array of POs
+ Vec_Ptr_t * vCis; // the array of PIs
+ Vec_Ptr_t * vCos; // the array of POs
Vec_Ptr_t * vObjs; // the array of all nodes (optional)
Vec_Ptr_t * vBufs; // the array of buffers
Aig_Obj_t * pConst1; // the constant 1 node
@@ -246,8 +246,8 @@ static inline Aig_Obj_t * Aig_Not( Aig_Obj_t * p ) { return (Aig_
static inline Aig_Obj_t * Aig_NotCond( Aig_Obj_t * p, int c ) { return (Aig_Obj_t *)((ABC_PTRUINT_T)(p) ^ (c)); }
static inline int Aig_IsComplement( Aig_Obj_t * p ) { return (int)((ABC_PTRUINT_T)(p) & 01); }
-static inline int Aig_ManPiNum( Aig_Man_t * p ) { return p->nObjs[AIG_OBJ_PI]; }
-static inline int Aig_ManPoNum( Aig_Man_t * p ) { return p->nObjs[AIG_OBJ_PO]; }
+static inline int Aig_ManCiNum( Aig_Man_t * p ) { return p->nObjs[AIG_OBJ_CI]; }
+static inline int Aig_ManCoNum( Aig_Man_t * p ) { return p->nObjs[AIG_OBJ_CO]; }
static inline int Aig_ManBufNum( Aig_Man_t * p ) { return p->nObjs[AIG_OBJ_BUF]; }
static inline int Aig_ManAndNum( Aig_Man_t * p ) { return p->nObjs[AIG_OBJ_AND]; }
static inline int Aig_ManExorNum( Aig_Man_t * p ) { return p->nObjs[AIG_OBJ_EXOR]; }
@@ -261,26 +261,26 @@ static inline int Aig_ManConstrNum( Aig_Man_t * p ) { return p->nC
static inline Aig_Obj_t * Aig_ManConst0( Aig_Man_t * p ) { return Aig_Not(p->pConst1); }
static inline Aig_Obj_t * Aig_ManConst1( Aig_Man_t * p ) { return p->pConst1; }
static inline Aig_Obj_t * Aig_ManGhost( Aig_Man_t * p ) { return &p->Ghost; }
-static inline Aig_Obj_t * Aig_ManPi( Aig_Man_t * p, int i ) { return (Aig_Obj_t *)Vec_PtrEntry(p->vPis, i); }
-static inline Aig_Obj_t * Aig_ManPo( Aig_Man_t * p, int i ) { return (Aig_Obj_t *)Vec_PtrEntry(p->vPos, i); }
-static inline Aig_Obj_t * Aig_ManLo( Aig_Man_t * p, int i ) { return (Aig_Obj_t *)Vec_PtrEntry(p->vPis, Aig_ManPiNum(p)-Aig_ManRegNum(p)+i); }
-static inline Aig_Obj_t * Aig_ManLi( Aig_Man_t * p, int i ) { return (Aig_Obj_t *)Vec_PtrEntry(p->vPos, Aig_ManPoNum(p)-Aig_ManRegNum(p)+i); }
+static inline Aig_Obj_t * Aig_ManCi( Aig_Man_t * p, int i ) { return (Aig_Obj_t *)Vec_PtrEntry(p->vCis, i); }
+static inline Aig_Obj_t * Aig_ManCo( Aig_Man_t * p, int i ) { return (Aig_Obj_t *)Vec_PtrEntry(p->vCos, i); }
+static inline Aig_Obj_t * Aig_ManLo( Aig_Man_t * p, int i ) { return (Aig_Obj_t *)Vec_PtrEntry(p->vCis, Aig_ManCiNum(p)-Aig_ManRegNum(p)+i); }
+static inline Aig_Obj_t * Aig_ManLi( Aig_Man_t * p, int i ) { return (Aig_Obj_t *)Vec_PtrEntry(p->vCos, Aig_ManCoNum(p)-Aig_ManRegNum(p)+i); }
static inline Aig_Obj_t * Aig_ManObj( Aig_Man_t * p, int i ) { return p->vObjs ? (Aig_Obj_t *)Vec_PtrEntry(p->vObjs, i) : NULL; }
static inline Aig_Type_t Aig_ObjType( Aig_Obj_t * pObj ) { return (Aig_Type_t)pObj->Type; }
static inline int Aig_ObjId( Aig_Obj_t * pObj ) { return pObj->Id; }
static inline int Aig_ObjIsNone( Aig_Obj_t * pObj ) { return pObj->Type == AIG_OBJ_NONE; }
static inline int Aig_ObjIsConst1( Aig_Obj_t * pObj ) { assert(!Aig_IsComplement(pObj)); return pObj->Type == AIG_OBJ_CONST1; }
-static inline int Aig_ObjIsPi( Aig_Obj_t * pObj ) { return pObj->Type == AIG_OBJ_PI; }
-static inline int Aig_ObjIsPo( Aig_Obj_t * pObj ) { return pObj->Type == AIG_OBJ_PO; }
+static inline int Aig_ObjIsCi( Aig_Obj_t * pObj ) { return pObj->Type == AIG_OBJ_CI; }
+static inline int Aig_ObjIsCo( Aig_Obj_t * pObj ) { return pObj->Type == AIG_OBJ_CO; }
static inline int Aig_ObjIsBuf( Aig_Obj_t * pObj ) { return pObj->Type == AIG_OBJ_BUF; }
static inline int Aig_ObjIsAnd( Aig_Obj_t * pObj ) { return pObj->Type == AIG_OBJ_AND; }
static inline int Aig_ObjIsExor( Aig_Obj_t * pObj ) { return pObj->Type == AIG_OBJ_EXOR; }
static inline int Aig_ObjIsNode( Aig_Obj_t * pObj ) { return pObj->Type == AIG_OBJ_AND || pObj->Type == AIG_OBJ_EXOR; }
-static inline int Aig_ObjIsTerm( Aig_Obj_t * pObj ) { return pObj->Type == AIG_OBJ_PI || pObj->Type == AIG_OBJ_PO || pObj->Type == AIG_OBJ_CONST1; }
+static inline int Aig_ObjIsTerm( Aig_Obj_t * pObj ) { return pObj->Type == AIG_OBJ_CI || pObj->Type == AIG_OBJ_CO || pObj->Type == AIG_OBJ_CONST1; }
static inline int Aig_ObjIsHash( Aig_Obj_t * pObj ) { return pObj->Type == AIG_OBJ_AND || pObj->Type == AIG_OBJ_EXOR; }
static inline int Aig_ObjIsChoice( Aig_Man_t * p, Aig_Obj_t * pObj ) { return p->pEquivs && p->pEquivs[pObj->Id] && pObj->nRefs > 0; }
-static inline int Aig_ObjIsCand( Aig_Obj_t * pObj ) { return pObj->Type == AIG_OBJ_PI || pObj->Type == AIG_OBJ_AND || pObj->Type == AIG_OBJ_EXOR; }
+static inline int Aig_ObjIsCand( Aig_Obj_t * pObj ) { return pObj->Type == AIG_OBJ_CI || pObj->Type == AIG_OBJ_AND || pObj->Type == AIG_OBJ_EXOR; }
static inline int Aig_ObjIsMarkA( Aig_Obj_t * pObj ) { return pObj->fMarkA; }
static inline void Aig_ObjSetMarkA( Aig_Obj_t * pObj ) { pObj->fMarkA = 1; }
@@ -347,7 +347,7 @@ static inline Aig_Obj_t * Aig_ObjCreateGhost( Aig_Man_t * p, Aig_Obj_t * p0, Ai
Aig_Obj_t * pGhost;
assert( Type != AIG_OBJ_AND || !Aig_ObjIsConst1(Aig_Regular(p0)) );
assert( p1 == NULL || !Aig_ObjIsConst1(Aig_Regular(p1)) );
- assert( Type == AIG_OBJ_PI || Aig_Regular(p0) != Aig_Regular(p1) );
+ assert( Type == AIG_OBJ_CI || Aig_Regular(p0) != Aig_Regular(p1) );
pGhost = Aig_ManGhost(p);
pGhost->Type = Type;
if ( p1 == NULL || Aig_Regular(p0)->Id < Aig_Regular(p1)->Id )
@@ -388,16 +388,16 @@ static inline void Aig_ManRecycleMemory( Aig_Man_t * p, Aig_Obj_t * pEntry )
/// ITERATORS ///
////////////////////////////////////////////////////////////////////////
-// iterator over the primary inputs
+// iterator over the combinational inputs
#define Aig_ManForEachCi( p, pObj, i ) \
- Vec_PtrForEachEntry( Aig_Obj_t *, p->vPis, pObj, i )
+ Vec_PtrForEachEntry( Aig_Obj_t *, p->vCis, pObj, i )
#define Aig_ManForEachCiReverse( p, pObj, i ) \
- Vec_PtrForEachEntryReverse( Aig_Obj_t *, p->vPis, pObj, i )
-// iterator over the primary outputs
+ Vec_PtrForEachEntryReverse( Aig_Obj_t *, p->vCis, pObj, i )
+// iterator over the combinational outputs
#define Aig_ManForEachCo( p, pObj, i ) \
- Vec_PtrForEachEntry( Aig_Obj_t *, p->vPos, pObj, i )
+ Vec_PtrForEachEntry( Aig_Obj_t *, p->vCos, pObj, i )
#define Aig_ManForEachCoReverse( p, pObj, i ) \
- Vec_PtrForEachEntryReverse( Aig_Obj_t *, p->vPos, pObj, i )
+ Vec_PtrForEachEntryReverse( Aig_Obj_t *, p->vCos, pObj, i )
// iterators 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
@@ -435,16 +435,16 @@ static inline int Aig_ObjFanoutNext( Aig_Man_t * p, int iFan ) { assert(iF
// iterator over the primary inputs
#define Aig_ManForEachPiSeq( p, pObj, i ) \
- Vec_PtrForEachEntryStop( Aig_Obj_t *, p->vPis, pObj, i, Aig_ManPiNum(p)-Aig_ManRegNum(p) )
+ Vec_PtrForEachEntryStop( Aig_Obj_t *, p->vCis, pObj, i, Aig_ManCiNum(p)-Aig_ManRegNum(p) )
// iterator over the latch outputs
#define Aig_ManForEachLoSeq( p, pObj, i ) \
- Vec_PtrForEachEntryStart( Aig_Obj_t *, p->vPis, pObj, i, Aig_ManPiNum(p)-Aig_ManRegNum(p) )
+ Vec_PtrForEachEntryStart( Aig_Obj_t *, p->vCis, pObj, i, Aig_ManCiNum(p)-Aig_ManRegNum(p) )
// iterator over the primary outputs
#define Aig_ManForEachPoSeq( p, pObj, i ) \
- Vec_PtrForEachEntryStop( Aig_Obj_t *, p->vPos, pObj, i, Aig_ManPoNum(p)-Aig_ManRegNum(p) )
+ Vec_PtrForEachEntryStop( Aig_Obj_t *, p->vCos, pObj, i, Aig_ManCoNum(p)-Aig_ManRegNum(p) )
// iterator over the latch inputs
#define Aig_ManForEachLiSeq( p, pObj, i ) \
- Vec_PtrForEachEntryStart( Aig_Obj_t *, p->vPos, pObj, i, Aig_ManPoNum(p)-Aig_ManRegNum(p) )
+ Vec_PtrForEachEntryStart( Aig_Obj_t *, p->vCos, pObj, i, Aig_ManCoNum(p)-Aig_ManRegNum(p) )
// iterator over the latch input and outputs
#define Aig_ManForEachLiLoSeq( p, pObjLi, pObjLo, k ) \
for ( k = 0; (k < Aig_ManRegNum(p)) && (((pObjLi) = Aig_ManLi(p, k)), 1) \
@@ -486,7 +486,7 @@ extern Aig_Obj_t * Aig_ManDupSimpleDfs_rec( Aig_Man_t * pNew, Aig_Man_t * p,
extern Aig_Man_t * Aig_ManDupSimple( Aig_Man_t * p );
extern Aig_Man_t * Aig_ManDupSimpleWithHints( Aig_Man_t * p, Vec_Int_t * vHints );
extern Aig_Man_t * Aig_ManDupSimpleDfs( Aig_Man_t * p );
-extern Aig_Man_t * Aig_ManDupSimpleDfsPart( Aig_Man_t * p, Vec_Ptr_t * vPis, Vec_Ptr_t * vPos );
+extern Aig_Man_t * Aig_ManDupSimpleDfsPart( Aig_Man_t * p, Vec_Ptr_t * vPis, Vec_Ptr_t * vCos );
extern Aig_Man_t * Aig_ManDupOrdered( Aig_Man_t * p );
extern Aig_Man_t * Aig_ManDupCof( Aig_Man_t * p, int iInput, int Value );
extern Aig_Man_t * Aig_ManDupTrim( Aig_Man_t * p );
@@ -520,8 +520,8 @@ extern void Aig_ManStop( Aig_Man_t * p );
extern void Aig_ManStopP( Aig_Man_t ** p );
extern int Aig_ManCleanup( Aig_Man_t * p );
extern int Aig_ManAntiCleanup( Aig_Man_t * p );
-extern int Aig_ManPiCleanup( Aig_Man_t * p );
-extern int Aig_ManPoCleanup( Aig_Man_t * p );
+extern int Aig_ManCiCleanup( Aig_Man_t * p );
+extern int Aig_ManCoCleanup( Aig_Man_t * p );
extern void Aig_ManPrintStats( Aig_Man_t * p );
extern void Aig_ManReportImprovement( Aig_Man_t * p, Aig_Man_t * pNew );
extern void Aig_ManSetRegNum( Aig_Man_t * p, int nRegs );
diff --git a/src/aig/aig/aigCheck.c b/src/aig/aig/aigCheck.c
index 6458cd6a..166b6e18 100644
--- a/src/aig/aig/aigCheck.c
+++ b/src/aig/aig/aigCheck.c
@@ -92,13 +92,13 @@ int Aig_ManCheck( Aig_Man_t * p )
}
}
// count the total number of nodes
- if ( Aig_ManObjNum(p) != 1 + Aig_ManPiNum(p) + Aig_ManPoNum(p) +
+ if ( Aig_ManObjNum(p) != 1 + Aig_ManCiNum(p) + Aig_ManCoNum(p) +
Aig_ManBufNum(p) + Aig_ManAndNum(p) + Aig_ManExorNum(p) )
{
printf( "Aig_ManCheck: The number of created nodes is wrong.\n" );
printf( "C1 = %d. Pi = %d. Po = %d. Buf = %d. And = %d. Xor = %d. Total = %d.\n",
- 1, Aig_ManPiNum(p), Aig_ManPoNum(p), Aig_ManBufNum(p), Aig_ManAndNum(p), Aig_ManExorNum(p),
- 1 + Aig_ManPiNum(p) + Aig_ManPoNum(p) + Aig_ManBufNum(p) + Aig_ManAndNum(p) + Aig_ManExorNum(p) );
+ 1, Aig_ManCiNum(p), Aig_ManCoNum(p), Aig_ManBufNum(p), Aig_ManAndNum(p), Aig_ManExorNum(p),
+ 1 + Aig_ManCiNum(p) + Aig_ManCoNum(p) + Aig_ManBufNum(p) + Aig_ManAndNum(p) + Aig_ManExorNum(p) );
printf( "Created = %d. Deleted = %d. Existing = %d.\n",
p->nCreated, p->nDeleted, p->nCreated - p->nDeleted );
return 0;
@@ -153,7 +153,7 @@ void Aig_ManCheckPhase( Aig_Man_t * p )
Aig_Obj_t * pObj;
int i;
Aig_ManForEachObj( p, pObj, i )
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
assert( (int)pObj->fPhase == 0 );
else
assert( (int)pObj->fPhase == (Aig_ObjPhaseReal(Aig_ObjChild0(pObj)) & Aig_ObjPhaseReal(Aig_ObjChild1(pObj))) );
diff --git a/src/aig/aig/aigDfs.c b/src/aig/aig/aigDfs.c
index 671dad0d..20830acb 100644
--- a/src/aig/aig/aigDfs.c
+++ b/src/aig/aig/aigDfs.c
@@ -66,7 +66,7 @@ int Aig_ManVerifyTopoOrder( Aig_Man_t * p )
return 0;
}
}
- else if ( Aig_ObjIsPo(pObj) || Aig_ObjIsBuf(pObj) )
+ else if ( Aig_ObjIsCo(pObj) || Aig_ObjIsBuf(pObj) )
{
pNext = Aig_ObjFanin0(pObj);
if ( !Aig_ObjIsTravIdCurrent(p,pNext) )
@@ -75,7 +75,7 @@ int Aig_ManVerifyTopoOrder( Aig_Man_t * p )
return 0;
}
}
- else if ( Aig_ObjIsPi(pObj) )
+ else if ( Aig_ObjIsCi(pObj) )
{
if ( p->pManTime )
{
@@ -86,7 +86,7 @@ int Aig_ManVerifyTopoOrder( Aig_Man_t * p )
nTerms = Tim_ManBoxInputNum( (Tim_Man_t *)p->pManTime, iBox );
for ( k = 0; k < nTerms; k++ )
{
- pNext = Aig_ManPo( p, iTerm1 + k );
+ pNext = Aig_ManCo( p, iTerm1 + k );
assert( Tim_ManBoxForCo( (Tim_Man_t *)p->pManTime, Aig_ObjPioNum(pNext) ) == iBox );
if ( !Aig_ObjIsTravIdCurrent(p,pNext) )
{
@@ -183,12 +183,12 @@ void Aig_ManDfsAll_rec( Aig_Man_t * p, Aig_Obj_t * pObj, Vec_Ptr_t * vNodes )
if ( Aig_ObjIsTravIdCurrent(p, pObj) )
return;
Aig_ObjSetTravIdCurrent(p, pObj);
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
{
Vec_PtrPush( vNodes, pObj );
return;
}
- if ( Aig_ObjIsPo(pObj) )
+ if ( Aig_ObjIsCo(pObj) )
{
Aig_ManDfsAll_rec( p, Aig_ObjFanin0(pObj), vNodes );
Vec_PtrPush( vNodes, pObj );
@@ -343,7 +343,7 @@ Vec_Ptr_t * Aig_ManDfsNodes( Aig_Man_t * p, Aig_Obj_t ** ppNodes, int nNodes )
// go through the nodes
vNodes = Vec_PtrAlloc( Aig_ManNodeNum(p) );
for ( i = 0; i < nNodes; i++ )
- if ( Aig_ObjIsPo(ppNodes[i]) )
+ if ( Aig_ObjIsCo(ppNodes[i]) )
Aig_ManDfs_rec( p, Aig_ObjFanin0(ppNodes[i]), vNodes );
else
Aig_ManDfs_rec( p, ppNodes[i], vNodes );
@@ -501,7 +501,7 @@ void Aig_ManChoiceLevel_rec( Aig_Man_t * p, Aig_Obj_t * pObj )
if ( Aig_ObjIsTravIdCurrent( p, pObj ) )
return;
Aig_ObjSetTravIdCurrent( p, pObj );
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
{
if ( p->pManTime )
{
@@ -512,7 +512,7 @@ void Aig_ManChoiceLevel_rec( Aig_Man_t * p, Aig_Obj_t * pObj )
nTerms = Tim_ManBoxInputNum( (Tim_Man_t *)p->pManTime, iBox );
for ( i = 0; i < nTerms; i++ )
{
- pNext = Aig_ManPo(p, iTerm1 + i);
+ pNext = Aig_ManCo(p, iTerm1 + i);
Aig_ManChoiceLevel_rec( p, pNext );
if ( LevelMax < Aig_ObjLevel(pNext) )
LevelMax = Aig_ObjLevel(pNext);
@@ -522,7 +522,7 @@ void Aig_ManChoiceLevel_rec( Aig_Man_t * p, Aig_Obj_t * pObj )
}
// printf( "%d ", pObj->Level );
}
- else if ( Aig_ObjIsPo(pObj) )
+ else if ( Aig_ObjIsCo(pObj) )
{
pNext = Aig_ObjFanin0(pObj);
Aig_ManChoiceLevel_rec( p, pNext );
@@ -721,7 +721,7 @@ void Aig_SupportSize_rec( Aig_Man_t * p, Aig_Obj_t * pObj, int * pCounter )
if ( Aig_ObjIsTravIdCurrent(p, pObj) )
return;
Aig_ObjSetTravIdCurrent(p, pObj);
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
{
(*pCounter)++;
return;
@@ -747,7 +747,7 @@ int Aig_SupportSize( Aig_Man_t * p, Aig_Obj_t * pObj )
{
int Counter = 0;
assert( !Aig_IsComplement(pObj) );
- assert( !Aig_ObjIsPo(pObj) );
+ assert( !Aig_ObjIsCo(pObj) );
Aig_ManIncrementTravId( p );
Aig_SupportSize_rec( p, pObj, &Counter );
return Counter;
@@ -794,7 +794,7 @@ void Aig_Support_rec( Aig_Man_t * p, Aig_Obj_t * pObj, Vec_Ptr_t * vSupp )
Aig_ObjSetTravIdCurrent(p, pObj);
if ( Aig_ObjIsConst1(pObj) )
return;
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
{
Vec_PtrPush( vSupp, pObj );
return;
@@ -820,7 +820,7 @@ Vec_Ptr_t * Aig_Support( Aig_Man_t * p, Aig_Obj_t * pObj )
{
Vec_Ptr_t * vSupp;
assert( !Aig_IsComplement(pObj) );
- assert( !Aig_ObjIsPo(pObj) );
+ assert( !Aig_ObjIsCo(pObj) );
Aig_ManIncrementTravId( p );
vSupp = Vec_PtrAlloc( 100 );
Aig_Support_rec( p, pObj, vSupp );
@@ -847,7 +847,7 @@ void Aig_SupportNodes( Aig_Man_t * p, Aig_Obj_t ** ppObjs, int nObjs, Vec_Ptr_t
for ( i = 0; i < nObjs; i++ )
{
assert( !Aig_IsComplement(ppObjs[i]) );
- if ( Aig_ObjIsPo(ppObjs[i]) )
+ if ( Aig_ObjIsCo(ppObjs[i]) )
Aig_Support_rec( p, Aig_ObjFanin0(ppObjs[i]), vSupp );
else
Aig_Support_rec( p, ppObjs[i], vSupp );
@@ -927,7 +927,7 @@ void Aig_Compose_rec( Aig_Man_t * p, Aig_Obj_t * pObj, Aig_Obj_t * pFunc, Aig_Ob
assert( !Aig_IsComplement(pObj) );
if ( Aig_ObjIsMarkA(pObj) )
return;
- if ( Aig_ObjIsConst1(pObj) || Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsConst1(pObj) || Aig_ObjIsCi(pObj) )
{
pObj->pData = pObj == pVar ? pFunc : pObj;
return;
@@ -953,13 +953,13 @@ void Aig_Compose_rec( Aig_Man_t * p, Aig_Obj_t * pObj, Aig_Obj_t * pFunc, Aig_Ob
Aig_Obj_t * Aig_Compose( Aig_Man_t * p, Aig_Obj_t * pRoot, Aig_Obj_t * pFunc, int iVar )
{
// quit if the PI variable is not defined
- if ( iVar >= Aig_ManPiNum(p) )
+ if ( iVar >= Aig_ManCiNum(p) )
{
printf( "Aig_Compose(): The PI variable %d is not defined.\n", iVar );
return NULL;
}
// recursively perform composition
- Aig_Compose_rec( p, Aig_Regular(pRoot), pFunc, Aig_ManPi(p, iVar) );
+ Aig_Compose_rec( p, Aig_Regular(pRoot), pFunc, Aig_ManCi(p, iVar) );
// clear the markings
Aig_ConeUnmark_rec( Aig_Regular(pRoot) );
return Aig_NotCond( (Aig_Obj_t *)Aig_Regular(pRoot)->pData, Aig_IsComplement(pRoot) );
diff --git a/src/aig/aig/aigDoms.c b/src/aig/aig/aigDoms.c
index 2bbb06b9..00350304 100644
--- a/src/aig/aig/aigDoms.c
+++ b/src/aig/aig/aigDoms.c
@@ -579,7 +579,7 @@ int Aig_ManMarkFlopTfi_rec( Aig_Man_t * p, Aig_Obj_t * pObj )
if ( Aig_ObjIsTravIdCurrent(p, pObj) )
return 0;
Aig_ObjSetTravIdCurrent(p, pObj);
- if ( Aig_ObjIsPi(pObj) || Aig_ObjIsConst1(pObj) )
+ if ( Aig_ObjIsCi(pObj) || Aig_ObjIsConst1(pObj) )
return 1;
Count = Aig_ManMarkFlopTfi_rec( p, Aig_ObjFanin0(pObj) );
if ( Aig_ObjIsNode(pObj) )
@@ -773,8 +773,8 @@ int Aig_ObjDomVolume_rec( Aig_Man_t * p, Aig_Obj_t * pObj )
Aig_ObjSetTravIdCurrent(p, pObj);
if ( pObj->fMarkA )
return 1;
-// assert( !Aig_ObjIsPi(pObj) && !Aig_ObjIsConst1(pObj) );
- if ( Aig_ObjIsPi(pObj) || Aig_ObjIsConst1(pObj) )
+// assert( !Aig_ObjIsCi(pObj) && !Aig_ObjIsConst1(pObj) );
+ if ( Aig_ObjIsCi(pObj) || Aig_ObjIsConst1(pObj) )
return 1;
Count = Aig_ObjDomVolume_rec( p, Aig_ObjFanin0(pObj) );
if ( Aig_ObjIsNode(pObj) )
@@ -826,7 +826,7 @@ int Aig_ObjDomDeref_rec( Aig_Obj_t * pNode )
assert( pNode->nRefs == 0 );
if ( pNode->fMarkA )
return 1;
- if ( Aig_ObjIsPi(pNode) )
+ if ( Aig_ObjIsCi(pNode) )
return 0;
Counter += Aig_ObjDomDeref_rec( Aig_ObjFanin0(pNode) );
if ( Aig_ObjIsNode(pNode) )
@@ -854,7 +854,7 @@ int Aig_ObjDomRef_rec( Aig_Obj_t * pNode )
assert( pNode->nRefs == 1 );
if ( pNode->fMarkA )
return 1;
- if ( Aig_ObjIsPi(pNode) )
+ if ( Aig_ObjIsCi(pNode) )
return 0;
Counter += Aig_ObjDomRef_rec( Aig_ObjFanin0(pNode) );
if ( Aig_ObjIsNode(pNode) )
@@ -880,7 +880,7 @@ int Aig_ObjDomDomed( Aig_Sto_t * pSto, Aig_Dom_t * pDom )
Counter0 = 0;
Aig_DomForEachNode( pSto->pAig, pDom, pObj, i )
{
- assert( !Aig_ObjIsPi(pObj) );
+ assert( !Aig_ObjIsCi(pObj) );
Counter0 += Aig_ObjDomDeref_rec( Aig_ObjFanin0(pObj) );
if ( Aig_ObjIsNode(pObj) )
Counter0 += Aig_ObjDomDeref_rec( Aig_ObjFanin1(pObj) );
@@ -888,7 +888,7 @@ int Aig_ObjDomDomed( Aig_Sto_t * pSto, Aig_Dom_t * pDom )
Counter1 = 0;
Aig_DomForEachNode( pSto->pAig, pDom, pObj, i )
{
- assert( !Aig_ObjIsPi(pObj) );
+ assert( !Aig_ObjIsCi(pObj) );
Counter1 += Aig_ObjDomRef_rec( Aig_ObjFanin0(pObj) );
if ( Aig_ObjIsNode(pObj) )
Counter1 += Aig_ObjDomRef_rec( Aig_ObjFanin1(pObj) );
@@ -1124,7 +1124,7 @@ void Aig_ManComputeDomsForCofactoring( Aig_Man_t * pAig )
pSto = Aig_ManComputeDomsNodes( pAig, 1 );
Aig_ManForEachObj( pAig, pObj, i )
{
- if ( !Aig_ObjIsPi(pObj) && !Aig_ObjIsNode(pObj) )
+ if ( !Aig_ObjIsCi(pObj) && !Aig_ObjIsNode(pObj) )
continue;
if ( Aig_ObjRefs(pObj) < 10 )
continue;
diff --git a/src/aig/aig/aigDup.c b/src/aig/aig/aigDup.c
index 3c5e6b3b..9b993c86 100644
--- a/src/aig/aig/aigDup.c
+++ b/src/aig/aig/aigDup.c
@@ -222,7 +222,7 @@ Aig_Man_t * Aig_ManDupSimpleDfs( Aig_Man_t * p )
}
// duplicate internal nodes
Aig_ManForEachObj( p, pObj, i )
- if ( !Aig_ObjIsPo(pObj) )
+ if ( !Aig_ObjIsCo(pObj) )
{
Aig_ManDupSimpleDfs_rec( pNew, p, pObj );
assert( pObj->Level == ((Aig_Obj_t*)pObj->pData)->Level );
@@ -322,12 +322,12 @@ Aig_Man_t * Aig_ManDupOrdered( Aig_Man_t * p )
{
pObjNew = Aig_Oper( pNew, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj), Aig_ObjType(pObj) );
}
- else if ( Aig_ObjIsPi(pObj) )
+ else if ( Aig_ObjIsCi(pObj) )
{
pObjNew = Aig_ObjCreateCi( pNew );
pObjNew->Level = pObj->Level;
}
- else if ( Aig_ObjIsPo(pObj) )
+ else if ( Aig_ObjIsCo(pObj) )
{
pObjNew = Aig_ObjCreateCo( pNew, Aig_ObjChild0Copy(pObj) );
}
@@ -466,9 +466,9 @@ Aig_Man_t * Aig_ManDupTrim( Aig_Man_t * p )
{
if ( Aig_ObjIsNode(pObj) )
pObjNew = Aig_Oper( pNew, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj), Aig_ObjType(pObj) );
- else if ( Aig_ObjIsPi(pObj) )
+ else if ( Aig_ObjIsCi(pObj) )
pObjNew = (Aig_ObjRefs(pObj) > 0 || Saig_ObjIsLo(p, pObj)) ? Aig_ObjCreateCi(pNew) : NULL;
- else if ( Aig_ObjIsPo(pObj) )
+ else if ( Aig_ObjIsCo(pObj) )
pObjNew = Aig_ObjCreateCo( pNew, Aig_ObjChild0Copy(pObj) );
else if ( Aig_ObjIsConst1(pObj) )
pObjNew = Aig_ManConst1(pNew);
@@ -524,12 +524,12 @@ Aig_Man_t * Aig_ManDupExor( Aig_Man_t * p )
{
pObjNew = Aig_Oper( pNew, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj), Aig_ObjType(pObj) );
}
- else if ( Aig_ObjIsPi(pObj) )
+ else if ( Aig_ObjIsCi(pObj) )
{
pObjNew = Aig_ObjCreateCi( pNew );
pObjNew->Level = pObj->Level;
}
- else if ( Aig_ObjIsPo(pObj) )
+ else if ( Aig_ObjIsCo(pObj) )
{
pObjNew = Aig_ObjCreateCo( pNew, Aig_ObjChild0Copy(pObj) );
}
@@ -626,14 +626,14 @@ Aig_Man_t * Aig_ManDupDfs( Aig_Man_t * p )
Aig_ManConst1(pNew)->pHaig = Aig_ManConst1(p)->pHaig;
Aig_ManForEachObj( p, pObj, i )
{
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
{
pObjNew = Aig_ObjCreateCi( pNew );
pObjNew->Level = pObj->Level;
pObjNew->pHaig = pObj->pHaig;
pObj->pData = pObjNew;
}
- else if ( Aig_ObjIsPo(pObj) )
+ else if ( Aig_ObjIsCo(pObj) )
{
Aig_ManDupDfs_rec( pNew, p, Aig_ObjFanin0(pObj) );
// assert( pObj->Level == ((Aig_Obj_t*)pObj->pData)->Level );
@@ -677,16 +677,16 @@ Vec_Ptr_t * Aig_ManOrderPios( Aig_Man_t * p, Aig_Man_t * pOrder )
Vec_Ptr_t * vPios;
Aig_Obj_t * pObj;
int i;
- assert( Aig_ManPiNum(p) == Aig_ManPiNum(pOrder) );
- assert( Aig_ManPoNum(p) == Aig_ManPoNum(pOrder) );
+ assert( Aig_ManCiNum(p) == Aig_ManCiNum(pOrder) );
+ assert( Aig_ManCoNum(p) == Aig_ManCoNum(pOrder) );
Aig_ManSetPioNumbers( pOrder );
- vPios = Vec_PtrAlloc( Aig_ManPiNum(p) + Aig_ManPoNum(p) );
+ vPios = Vec_PtrAlloc( Aig_ManCiNum(p) + Aig_ManCoNum(p) );
Aig_ManForEachObj( pOrder, pObj, i )
{
- if ( Aig_ObjIsPi(pObj) )
- Vec_PtrPush( vPios, Aig_ManPi(p, Aig_ObjPioNum(pObj)) );
- else if ( Aig_ObjIsPo(pObj) )
- Vec_PtrPush( vPios, Aig_ManPo(p, Aig_ObjPioNum(pObj)) );
+ if ( Aig_ObjIsCi(pObj) )
+ Vec_PtrPush( vPios, Aig_ManCi(p, Aig_ObjPioNum(pObj)) );
+ else if ( Aig_ObjIsCo(pObj) )
+ Vec_PtrPush( vPios, Aig_ManCo(p, Aig_ObjPioNum(pObj)) );
}
Aig_ManCleanPioNumbers( pOrder );
return vPios;
@@ -708,7 +708,7 @@ Aig_Obj_t * Aig_ManDupDfsGuided_rec( Aig_Man_t * pNew, Aig_Man_t * p, Aig_Obj_t
Aig_Obj_t * pObjNew, * pEquivNew = NULL;
if ( pObj->pData )
return (Aig_Obj_t *)pObj->pData;
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
return NULL;
if ( p->pEquivs && Aig_ObjEquiv(p, pObj) )
pEquivNew = Aig_ManDupDfsGuided_rec( pNew, p, Aig_ObjEquiv(p, pObj) );
@@ -773,14 +773,14 @@ Aig_Man_t * Aig_ManDupDfsGuided( Aig_Man_t * p, Vec_Ptr_t * vPios )
Aig_ManConst1(pNew)->pHaig = Aig_ManConst1(p)->pHaig;
Vec_PtrForEachEntry( Aig_Obj_t *, vPios, pObj, i )
{
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
{
pObjNew = Aig_ObjCreateCi( pNew );
pObjNew->Level = pObj->Level;
Aig_Regular(pObjNew)->pHaig = pObj->pHaig;
pObj->pData = pObjNew;
}
- else if ( Aig_ObjIsPo(pObj) )
+ else if ( Aig_ObjIsCo(pObj) )
{
Aig_ManDupDfsGuided_rec( pNew, p, Aig_ObjFanin0(pObj) );
// assert( pObj->Level == ((Aig_Obj_t*)pObj->pData)->Level );
@@ -991,12 +991,12 @@ Aig_Man_t * Aig_ManDupRepres( Aig_Man_t * p )
{
if ( Aig_ObjIsNode(pObj) )
pObj->pData = Aig_And( pNew, Aig_ObjChild0Repres(p, pObj), Aig_ObjChild1Repres(p, pObj) );
- else if ( Aig_ObjIsPi(pObj) )
+ else if ( Aig_ObjIsCi(pObj) )
{
pObj->pData = Aig_ObjCreateCi(pNew);
pObj->pData = Aig_ObjGetRepres( p, pObj );
}
- else if ( Aig_ObjIsPo(pObj) )
+ else if ( Aig_ObjIsCo(pObj) )
pObj->pData = Aig_ObjCreateCo( pNew, Aig_ObjChild0Repres(p, pObj) );
else if ( Aig_ObjIsConst1(pObj) )
pObj->pData = Aig_ManConst1(pNew);
@@ -1065,9 +1065,9 @@ Aig_Man_t * Aig_ManDupRepresDfs( Aig_Man_t * p )
{
if ( Aig_ObjIsNode(pObj) )
continue;
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
pObj->pData = Aig_ObjCreateCi(pNew);
- else if ( Aig_ObjIsPo(pObj) )
+ else if ( Aig_ObjIsCo(pObj) )
{
Aig_ManDupRepres_rec( pNew, p, Aig_ObjFanin0(pObj) );
pObj->pData = Aig_ObjCreateCo( pNew, Aig_ObjChild0Repres(p, pObj) );
@@ -1107,9 +1107,9 @@ Aig_Man_t * Aig_ManCreateMiter( Aig_Man_t * p1, Aig_Man_t * p2, int Oper )
int i;
assert( Aig_ManRegNum(p1) == 0 );
assert( Aig_ManRegNum(p2) == 0 );
- assert( Aig_ManPoNum(p1) == 1 );
- assert( Aig_ManPoNum(p2) == 1 );
- assert( Aig_ManPiNum(p1) == Aig_ManPiNum(p2) );
+ assert( Aig_ManCoNum(p1) == 1 );
+ assert( Aig_ManCoNum(p2) == 1 );
+ assert( Aig_ManCiNum(p1) == Aig_ManCiNum(p2) );
pNew = Aig_ManStart( Aig_ManObjNumMax(p1) + Aig_ManObjNumMax(p2) );
// add first AIG
Aig_ManConst1(p1)->pData = Aig_ManConst1(pNew);
@@ -1120,18 +1120,18 @@ Aig_Man_t * Aig_ManCreateMiter( Aig_Man_t * p1, Aig_Man_t * p2, int Oper )
// add second AIG
Aig_ManConst1(p2)->pData = Aig_ManConst1(pNew);
Aig_ManForEachCi( p2, pObj, i )
- pObj->pData = Aig_ManPi( pNew, i );
+ pObj->pData = Aig_ManCi( pNew, i );
Aig_ManForEachNode( p2, pObj, i )
pObj->pData = Aig_And( pNew, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj) );
// add the output
if ( Oper == 0 ) // XOR
- pObj = Aig_Exor( pNew, Aig_ObjChild0Copy(Aig_ManPo(p1,0)), Aig_ObjChild0Copy(Aig_ManPo(p2,0)) );
+ pObj = Aig_Exor( pNew, Aig_ObjChild0Copy(Aig_ManCo(p1,0)), Aig_ObjChild0Copy(Aig_ManCo(p2,0)) );
else if ( Oper == 1 ) // implication is PO(p1) -> PO(p2) ... complement is PO(p1) & !PO(p2)
- pObj = Aig_And( pNew, Aig_ObjChild0Copy(Aig_ManPo(p1,0)), Aig_Not(Aig_ObjChild0Copy(Aig_ManPo(p2,0))) );
+ pObj = Aig_And( pNew, Aig_ObjChild0Copy(Aig_ManCo(p1,0)), Aig_Not(Aig_ObjChild0Copy(Aig_ManCo(p2,0))) );
else if ( Oper == 2 ) // OR
- pObj = Aig_Or( pNew, Aig_ObjChild0Copy(Aig_ManPo(p1,0)), Aig_ObjChild0Copy(Aig_ManPo(p2,0)) );
+ pObj = Aig_Or( pNew, Aig_ObjChild0Copy(Aig_ManCo(p1,0)), Aig_ObjChild0Copy(Aig_ManCo(p2,0)) );
else if ( Oper == 3 ) // AND
- pObj = Aig_And( pNew, Aig_ObjChild0Copy(Aig_ManPo(p1,0)), Aig_ObjChild0Copy(Aig_ManPo(p2,0)) );
+ pObj = Aig_And( pNew, Aig_ObjChild0Copy(Aig_ManCo(p1,0)), Aig_ObjChild0Copy(Aig_ManCo(p2,0)) );
else
assert( 0 );
Aig_ObjCreateCo( pNew, pObj );
@@ -1209,7 +1209,7 @@ Aig_Man_t * Aig_ManDupOneOutput( Aig_Man_t * p, int iPoNum, int fAddRegs )
Aig_Obj_t * pObj;
int i;
assert( Aig_ManRegNum(p) > 0 );
- assert( iPoNum < Aig_ManPoNum(p)-Aig_ManRegNum(p) );
+ assert( iPoNum < Aig_ManCoNum(p)-Aig_ManRegNum(p) );
// create the new manager
pNew = Aig_ManStart( Aig_ManObjNumMax(p) );
pNew->pName = Abc_UtilStrsav( p->pName );
@@ -1227,7 +1227,7 @@ Aig_Man_t * Aig_ManDupOneOutput( Aig_Man_t * p, int iPoNum, int fAddRegs )
Aig_ManForEachNode( p, pObj, i )
pObj->pData = Aig_And( pNew, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj) );
// create the PO
- pObj = Aig_ManPo( p, iPoNum );
+ pObj = Aig_ManCo( p, iPoNum );
Aig_ObjCreateCo( pNew, Aig_ObjChild0Copy(pObj) );
// create register inputs with MUXes
if ( fAddRegs )
@@ -1317,7 +1317,7 @@ Aig_Man_t * Aig_ManDupArray( Vec_Ptr_t * vArray )
Vec_PtrForEachEntry( Aig_Man_t *, vArray, pNew, k )
{
assert( Aig_ManRegNum(pNew) == 0 );
- assert( Aig_ManPiNum(pNew) == Aig_ManPiNum(p) );
+ assert( Aig_ManCiNum(pNew) == Aig_ManCiNum(p) );
}
// create the new manager
pNew = Aig_ManStart( 10000 );
@@ -1329,7 +1329,7 @@ Aig_Man_t * Aig_ManDupArray( Vec_Ptr_t * vArray )
{
Aig_ManConst1(p)->pData = Aig_ManConst1(pNew);
Aig_ManForEachCi( p, pObj, i )
- pObj->pData = Aig_ManPi( pNew, i );
+ pObj->pData = Aig_ManCi( pNew, i );
Aig_ManForEachNode( p, pObj, i )
pObj->pData = Aig_And( pNew, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj) );
Aig_ManForEachCo( p, pObj, i )
@@ -1367,7 +1367,7 @@ Aig_Man_t * Aig_ManDupNodes( Aig_Man_t * pMan, Vec_Ptr_t * vArray )
pNew->pName = Abc_UtilStrsav( pMan->pName );
Aig_ManConst1(pMan)->pData = Aig_ManConst1(pNew);
Vec_PtrForEachEntry( Aig_Obj_t *, vObjs, pObj, i )
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
pObj->pData = Aig_ObjCreateCi(pNew);
Vec_PtrForEachEntry( Aig_Obj_t *, vObjs, pObj, i )
if ( Aig_ObjIsNode(pObj) )
diff --git a/src/aig/aig/aigFact.c b/src/aig/aig/aigFact.c
index 40885365..33e07161 100644
--- a/src/aig/aig/aigFact.c
+++ b/src/aig/aig/aigFact.c
@@ -45,7 +45,7 @@ ABC_NAMESPACE_IMPL_START
***********************************************************************/
void Aig_ManFindImplications_rec( Aig_Obj_t * pObj, Vec_Ptr_t * vImplics )
{
- if ( Aig_IsComplement(pObj) || Aig_ObjIsPi(pObj) )
+ if ( Aig_IsComplement(pObj) || Aig_ObjIsCi(pObj) )
{
Vec_PtrPushUnique( vImplics, pObj );
return;
@@ -93,7 +93,7 @@ int Aig_ManFindConeOverlap_rec( Aig_Man_t * p, Aig_Obj_t * pNode )
if ( Aig_ObjIsTravIdCurrent( p, pNode ) )
return 0;
Aig_ObjSetTravIdCurrent( p, pNode );
- if ( Aig_ObjIsPi(pNode) )
+ if ( Aig_ObjIsCi(pNode) )
return 0;
if ( Aig_ManFindConeOverlap_rec( p, Aig_ObjFanin0(pNode) ) )
return 1;
@@ -142,7 +142,7 @@ Aig_Obj_t * Aig_ManDeriveNewCone_rec( Aig_Man_t * p, Aig_Obj_t * pNode )
if ( Aig_ObjIsTravIdCurrent( p, pNode ) )
return (Aig_Obj_t *)pNode->pData;
Aig_ObjSetTravIdCurrent( p, pNode );
- if ( Aig_ObjIsPi(pNode) )
+ if ( Aig_ObjIsCi(pNode) )
return (Aig_Obj_t *)(pNode->pData = pNode);
Aig_ManDeriveNewCone_rec( p, Aig_ObjFanin0(pNode) );
Aig_ManDeriveNewCone_rec( p, Aig_ObjFanin1(pNode) );
@@ -194,7 +194,7 @@ Aig_Obj_t * Aig_ManFactorAlgebraic_int( Aig_Man_t * p, Aig_Obj_t * pPoA, Aig_Obj
int RetValue;
if ( Aig_ObjIsConst1(Aig_ObjFanin0(pPoA)) || Aig_ObjIsConst1(Aig_ObjFanin0(pPoB)) )
return NULL;
- if ( Aig_ObjIsPi(Aig_ObjFanin0(pPoB)) )
+ if ( Aig_ObjIsCi(Aig_ObjFanin0(pPoB)) )
return NULL;
// get the internal node representing function of A under assignment A = 'Value'
pNodeA = Aig_ObjChild0( pPoA );
@@ -229,10 +229,10 @@ Aig_Obj_t * Aig_ManFactorAlgebraic_int( Aig_Man_t * p, Aig_Obj_t * pPoA, Aig_Obj
***********************************************************************/
Aig_Obj_t * Aig_ManFactorAlgebraic( Aig_Man_t * p, int iPoA, int iPoB, int Value )
{
- assert( iPoA >= 0 && iPoA < Aig_ManPoNum(p) );
- assert( iPoB >= 0 && iPoB < Aig_ManPoNum(p) );
+ assert( iPoA >= 0 && iPoA < Aig_ManCoNum(p) );
+ assert( iPoB >= 0 && iPoB < Aig_ManCoNum(p) );
assert( Value == 0 || Value == 1 );
- return Aig_ManFactorAlgebraic_int( p, Aig_ManPo(p, iPoA), Aig_ManPo(p, iPoB), Value );
+ return Aig_ManFactorAlgebraic_int( p, Aig_ManCo(p, iPoA), Aig_ManCo(p, iPoB), Value );
}
/**Function*************************************************************
@@ -501,7 +501,7 @@ int Aig_SuppMinHighlightCone_rec( Aig_Man_t * p, Aig_Obj_t * pObj )
if ( Aig_ObjIsTravIdPrevious( p, pObj ) ) // visited, no marks there
return 0;
Aig_ObjSetTravIdPrevious( p, pObj );
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
return 0;
RetValue = Aig_SuppMinHighlightCone_rec( p, Aig_ObjFanin0(pObj) ) |
Aig_SuppMinHighlightCone_rec( p, Aig_ObjFanin1(pObj) );
@@ -552,7 +552,7 @@ int Aig_SuppMinHighlightCone( Aig_Man_t * p, Aig_Obj_t * pRoot, Vec_Ptr_t * vOrG
void Aig_SuppMinCollectSuper_rec( Aig_Obj_t * pObj, Vec_Ptr_t * vSuper )
{
// if the new node is complemented or a PI, another gate begins
- if ( Aig_IsComplement(pObj) || Aig_ObjIsPi(pObj) ) // || (Aig_ObjRefs(pObj) > 1) )
+ if ( Aig_IsComplement(pObj) || Aig_ObjIsCi(pObj) ) // || (Aig_ObjRefs(pObj) > 1) )
{
Vec_PtrPushUnique( vSuper, Aig_Not(pObj) );
return;
@@ -577,7 +577,7 @@ Vec_Ptr_t * Aig_SuppMinCollectSuper( Aig_Obj_t * pObj )
{
Vec_Ptr_t * vSuper;
assert( !Aig_IsComplement(pObj) );
- assert( !Aig_ObjIsPi(pObj) );
+ assert( !Aig_ObjIsCi(pObj) );
vSuper = Vec_PtrAlloc( 4 );
Aig_SuppMinCollectSuper_rec( Aig_ObjChild0(pObj), vSuper );
Aig_SuppMinCollectSuper_rec( Aig_ObjChild1(pObj), vSuper );
@@ -607,7 +607,7 @@ Aig_Obj_t * Aig_ManSupportMinimization( Aig_Man_t * p, Aig_Obj_t * pCond, Aig_Ob
int RetValue;
*pStatus = 0;
// if pCond is not OR
- if ( !Aig_IsComplement(pCond) || Aig_ObjIsPi(Aig_Regular(pCond)) || Aig_ObjIsConst1(Aig_Regular(pCond)) )
+ if ( !Aig_IsComplement(pCond) || Aig_ObjIsCi(Aig_Regular(pCond)) || Aig_ObjIsConst1(Aig_Regular(pCond)) )
{
*pStatus = -1;
return NULL;
diff --git a/src/aig/aig/aigInter.c b/src/aig/aig/aigInter.c
index 1210a335..fcf32236 100644
--- a/src/aig/aig/aigInter.c
+++ b/src/aig/aig/aigInter.c
@@ -56,20 +56,20 @@ void Aig_ManInterFast( Aig_Man_t * pManOn, Aig_Man_t * pManOff, int fVerbose )
int Lits[3], status, i;
// int clk = clock();
- assert( Aig_ManPiNum(pManOn) == Aig_ManPiNum(pManOff) );
- assert( Aig_ManPoNum(pManOn) == Aig_ManPoNum(pManOff) );
+ assert( Aig_ManCiNum(pManOn) == Aig_ManCiNum(pManOff) );
+ assert( Aig_ManCoNum(pManOn) == Aig_ManCoNum(pManOff) );
// derive CNFs
- pManOn->nRegs = Aig_ManPoNum(pManOn);
- pCnfOn = Cnf_Derive( pManOn, Aig_ManPoNum(pManOn) );
+ pManOn->nRegs = Aig_ManCoNum(pManOn);
+ pCnfOn = Cnf_Derive( pManOn, Aig_ManCoNum(pManOn) );
pManOn->nRegs = 0;
- pManOff->nRegs = Aig_ManPoNum(pManOn);
- pCnfOff = Cnf_Derive( pManOff, Aig_ManPoNum(pManOff) );
+ pManOff->nRegs = Aig_ManCoNum(pManOn);
+ pCnfOff = Cnf_Derive( pManOff, Aig_ManCoNum(pManOff) );
pManOff->nRegs = 0;
-// pCnfOn = Cnf_DeriveSimple( pManOn, Aig_ManPoNum(pManOn) );
-// pCnfOff = Cnf_DeriveSimple( pManOff, Aig_ManPoNum(pManOn) );
+// pCnfOn = Cnf_DeriveSimple( pManOn, Aig_ManCoNum(pManOn) );
+// pCnfOff = Cnf_DeriveSimple( pManOff, Aig_ManCoNum(pManOn) );
Cnf_DataLift( pCnfOff, pCnfOn->nVars );
// start the solver
@@ -104,7 +104,7 @@ void Aig_ManInterFast( Aig_Man_t * pManOn, Aig_Man_t * pManOff, int fVerbose )
// collect the common variables
Aig_ManForEachCi( pManOn, pObj, i )
{
- pObj2 = Aig_ManPi( pManOff, i );
+ pObj2 = Aig_ManCi( pManOff, i );
Lits[0] = toLitCond( pCnfOn->pVarNums[pObj->Id], 0 );
Lits[1] = toLitCond( pCnfOff->pVarNums[pObj2->Id], 1 );
@@ -121,7 +121,7 @@ void Aig_ManInterFast( Aig_Man_t * pManOn, Aig_Man_t * pManOff, int fVerbose )
// solve incremental SAT problems
Aig_ManForEachCo( pManOn, pObj, i )
{
- pObj2 = Aig_ManPo( pManOff, i );
+ pObj2 = Aig_ManCo( pManOff, i );
Lits[0] = toLitCond( pCnfOn->pVarNums[pObj->Id], 0 );
Lits[1] = toLitCond( pCnfOff->pVarNums[pObj2->Id], 0 );
@@ -159,7 +159,7 @@ Aig_Man_t * Aig_ManInter( Aig_Man_t * pManOn, Aig_Man_t * pManOff, int fRelation
int clk;
int iLast = -1; // Suppress "might be used uninitialized"
- assert( Aig_ManPiNum(pManOn) == Aig_ManPiNum(pManOff) );
+ assert( Aig_ManCiNum(pManOn) == Aig_ManCiNum(pManOff) );
clk = clock();
// derive CNFs
@@ -210,14 +210,14 @@ clk = clock();
// add PI clauses
// collect the common variables
- vVarsAB = Vec_IntAlloc( Aig_ManPiNum(pManOn) );
+ vVarsAB = Vec_IntAlloc( Aig_ManCiNum(pManOn) );
if ( fRelation )
Vec_IntPush( vVarsAB, iLast );
Aig_ManForEachCi( pManOn, pObj, i )
{
Vec_IntPush( vVarsAB, pCnfOn->pVarNums[pObj->Id] );
- pObj2 = Aig_ManPi( pManOff, i );
+ pObj2 = Aig_ManCi( pManOff, i );
Lits[0] = toLitCond( pCnfOn->pVarNums[pObj->Id], 0 );
Lits[1] = toLitCond( pCnfOff->pVarNums[pObj2->Id], 1 );
diff --git a/src/aig/aig/aigJust.c b/src/aig/aig/aigJust.c
index b15190e6..a6df4a1b 100644
--- a/src/aig/aig/aigJust.c
+++ b/src/aig/aig/aigJust.c
@@ -109,7 +109,7 @@ int Aig_NtkFindSatAssign_rec( Aig_Man_t * pAig, Aig_Obj_t * pNode, int Value, Ve
return ((int)pNode->fMarkA == Value);
Aig_ObjSetTravIdCurrent(pAig, pNode);
pNode->fMarkA = Value;
- if ( Aig_ObjIsPi(pNode) )
+ if ( Aig_ObjIsCi(pNode) )
{
// if ( Aig_ObjId(pNode) % 1000 == 0 )
// Value ^= 1;
@@ -162,7 +162,7 @@ int Aig_NtkFindSatAssign_rec( Aig_Man_t * pAig, Aig_Obj_t * pNode, int Value, Ve
int Aig_ObjFindSatAssign( Aig_Man_t * pAig, Aig_Obj_t * pNode, int Value, Vec_Int_t * vSuppLits )
{
int i;
- if ( Aig_ObjIsPo(pNode) )
+ if ( Aig_ObjIsCo(pNode) )
return Aig_ObjFindSatAssign( pAig, Aig_ObjFanin0(pNode), Value ^ Aig_ObjFaninC0(pNode), vSuppLits );
for ( i = 0; i < 8; i++ )
{
@@ -193,10 +193,10 @@ int Aig_ObjTerSimulate_rec( Aig_Man_t * pAig, Aig_Obj_t * pNode )
if ( Aig_ObjIsTravIdCurrent(pAig, pNode) )
return Aig_ObjGetTerValue( pNode );
Aig_ObjSetTravIdCurrent( pAig, pNode );
- if ( Aig_ObjIsPi(pNode) )
+ if ( Aig_ObjIsCi(pNode) )
return Aig_ObjSetTerValue( pNode, AIG_VALX );
Value0 = Aig_ObjNotCondTerValue( Aig_ObjTerSimulate_rec(pAig, Aig_ObjFanin0(pNode)), Aig_ObjFaninC0(pNode) );
- if ( Aig_ObjIsPo(pNode) || Value0 == AIG_VAL0 )
+ if ( Aig_ObjIsCo(pNode) || Value0 == AIG_VAL0 )
return Aig_ObjSetTerValue( pNode, Value0 );
assert( Aig_ObjIsNode(pNode) );
Value1 = Aig_ObjNotCondTerValue( Aig_ObjTerSimulate_rec(pAig, Aig_ObjFanin1(pNode)), Aig_ObjFaninC1(pNode) );
@@ -221,7 +221,7 @@ int Aig_ObjTerSimulate( Aig_Man_t * pAig, Aig_Obj_t * pNode, Vec_Int_t * vSuppLi
Aig_ManIncrementTravId( pAig );
Vec_IntForEachEntry( vSuppLits, Entry, i )
{
- pObj = Aig_ManPi( pAig, Abc_Lit2Var(Entry) );
+ pObj = Aig_ManCi( pAig, Abc_Lit2Var(Entry) );
Aig_ObjSetTerValue( pObj, Abc_LitIsCompl(Entry) ? AIG_VAL0 : AIG_VAL1 );
Aig_ObjSetTravIdCurrent( pAig, pObj );
//printf( "%d ", Entry );
@@ -292,7 +292,7 @@ void Aig_ManJustExperiment( Aig_Man_t * pAig )
}
Vec_IntFree( vSuppLits );
printf( "PO =%6d. C0 =%6d. C0f =%6d. C1 =%6d. C1f =%6d. (%6.2f %%) Ave =%4.1f ",
- Aig_ManPoNum(pAig), Count0, Count0f, Count1, Count1f, 100.0*(Count0+Count1)/Aig_ManPoNum(pAig), 1.0*nTotalLits/(Count0+Count1) );
+ Aig_ManCoNum(pAig), Count0, Count0f, Count1, Count1f, 100.0*(Count0+Count1)/Aig_ManCoNum(pAig), 1.0*nTotalLits/(Count0+Count1) );
Abc_PrintTime( 1, "T", clock() - clk );
Aig_ManCleanMarkAB( pAig );
Aig_ManPackStop( pPack );
diff --git a/src/aig/aig/aigMan.c b/src/aig/aig/aigMan.c
index 46cdb260..ed8cf8e9 100644
--- a/src/aig/aig/aigMan.c
+++ b/src/aig/aig/aigMan.c
@@ -56,8 +56,8 @@ Aig_Man_t * Aig_ManStart( int nNodesMax )
p->nTravIds = 1;
p->fCatchExor = 0;
// allocate arrays for nodes
- p->vPis = Vec_PtrAlloc( 100 );
- p->vPos = Vec_PtrAlloc( 100 );
+ p->vCis = Vec_PtrAlloc( 100 );
+ p->vCos = Vec_PtrAlloc( 100 );
p->vObjs = Vec_PtrAlloc( 1000 );
p->vBufs = Vec_PtrAlloc( 100 );
// prepare the internal memory manager
@@ -198,8 +198,8 @@ void Aig_ManStop( Aig_Man_t * p )
Aig_ManStop( p->pManExdc );
// Aig_TableProfile( p );
Aig_MmFixedStop( p->pMemObjs, 0 );
- Vec_PtrFreeP( &p->vPis );
- Vec_PtrFreeP( &p->vPos );
+ Vec_PtrFreeP( &p->vCis );
+ Vec_PtrFreeP( &p->vCos );
Vec_PtrFreeP( &p->vObjs );
Vec_PtrFreeP( &p->vBufs );
Vec_IntFreeP( &p->vLevelR );
@@ -287,11 +287,11 @@ int Aig_ManCleanup( Aig_Man_t * p )
int Aig_ManAntiCleanup( Aig_Man_t * p )
{
Aig_Obj_t * pNode;
- int i, nNodesOld = Aig_ManPoNum(p);
+ int i, nNodesOld = Aig_ManCoNum(p);
Aig_ManForEachObj( p, pNode, i )
if ( Aig_ObjIsNode(pNode) && Aig_ObjRefs(pNode) == 0 )
Aig_ObjCreateCo( p, pNode );
- return nNodesOld - Aig_ManPoNum(p);
+ return nNodesOld - Aig_ManCoNum(p);
}
/**Function*************************************************************
@@ -305,24 +305,24 @@ int Aig_ManAntiCleanup( Aig_Man_t * p )
SeeAlso []
***********************************************************************/
-int Aig_ManPiCleanup( Aig_Man_t * p )
+int Aig_ManCiCleanup( Aig_Man_t * p )
{
Aig_Obj_t * pObj;
- int i, k = 0, nPisOld = Aig_ManPiNum(p);
- Vec_PtrForEachEntry( Aig_Obj_t *, p->vPis, pObj, i )
+ int i, k = 0, nPisOld = Aig_ManCiNum(p);
+ Vec_PtrForEachEntry( Aig_Obj_t *, p->vCis, pObj, i )
{
- if ( i >= Aig_ManPiNum(p) - Aig_ManRegNum(p) )
- Vec_PtrWriteEntry( p->vPis, k++, pObj );
+ if ( i >= Aig_ManCiNum(p) - Aig_ManRegNum(p) )
+ Vec_PtrWriteEntry( p->vCis, k++, pObj );
else if ( Aig_ObjRefs(pObj) > 0 )
- Vec_PtrWriteEntry( p->vPis, k++, pObj );
+ Vec_PtrWriteEntry( p->vCis, k++, pObj );
else
Vec_PtrWriteEntry( p->vObjs, pObj->Id, NULL );
}
- Vec_PtrShrink( p->vPis, k );
- p->nObjs[AIG_OBJ_PI] = Vec_PtrSize( p->vPis );
+ Vec_PtrShrink( p->vCis, k );
+ p->nObjs[AIG_OBJ_CI] = Vec_PtrSize( p->vCis );
if ( Aig_ManRegNum(p) )
- p->nTruePis = Aig_ManPiNum(p) - Aig_ManRegNum(p);
- return nPisOld - Aig_ManPiNum(p);
+ p->nTruePis = Aig_ManCiNum(p) - Aig_ManRegNum(p);
+ return nPisOld - Aig_ManCiNum(p);
}
/**Function*************************************************************
@@ -336,27 +336,27 @@ int Aig_ManPiCleanup( Aig_Man_t * p )
SeeAlso []
***********************************************************************/
-int Aig_ManPoCleanup( Aig_Man_t * p )
+int Aig_ManCoCleanup( Aig_Man_t * p )
{
Aig_Obj_t * pObj;
- int i, k = 0, nPosOld = Aig_ManPoNum(p);
- Vec_PtrForEachEntry( Aig_Obj_t *, p->vPos, pObj, i )
+ int i, k = 0, nPosOld = Aig_ManCoNum(p);
+ Vec_PtrForEachEntry( Aig_Obj_t *, p->vCos, pObj, i )
{
- if ( i >= Aig_ManPoNum(p) - Aig_ManRegNum(p) )
- Vec_PtrWriteEntry( p->vPos, k++, pObj );
+ if ( i >= Aig_ManCoNum(p) - Aig_ManRegNum(p) )
+ Vec_PtrWriteEntry( p->vCos, k++, pObj );
else if ( !Aig_ObjIsConst1(Aig_ObjFanin0(pObj)) || !Aig_ObjFaninC0(pObj) ) // non-const or const1
- Vec_PtrWriteEntry( p->vPos, k++, pObj );
+ Vec_PtrWriteEntry( p->vCos, k++, pObj );
else
{
Aig_ObjDisconnect( p, pObj );
Vec_PtrWriteEntry( p->vObjs, pObj->Id, NULL );
}
}
- Vec_PtrShrink( p->vPos, k );
- p->nObjs[AIG_OBJ_PO] = Vec_PtrSize( p->vPos );
+ Vec_PtrShrink( p->vCos, k );
+ p->nObjs[AIG_OBJ_CO] = Vec_PtrSize( p->vCos );
if ( Aig_ManRegNum(p) )
- p->nTruePos = Aig_ManPoNum(p) - Aig_ManRegNum(p);
- return nPosOld - Aig_ManPoNum(p);
+ p->nTruePos = Aig_ManCoNum(p) - Aig_ManRegNum(p);
+ return nPosOld - Aig_ManCoNum(p);
}
/**Function*************************************************************
@@ -395,8 +395,8 @@ void Aig_ManPrintStats( Aig_Man_t * p )
{
int nChoices = Aig_ManChoiceNum(p);
printf( "%-15s : ", p->pName );
- printf( "pi = %5d ", Aig_ManPiNum(p)-Aig_ManRegNum(p) );
- printf( "po = %5d ", Aig_ManPoNum(p)-Aig_ManRegNum(p) );
+ printf( "pi = %5d ", Aig_ManCiNum(p)-Aig_ManRegNum(p) );
+ printf( "po = %5d ", Aig_ManCoNum(p)-Aig_ManRegNum(p) );
if ( Aig_ManRegNum(p) )
printf( "lat = %5d ", Aig_ManRegNum(p) );
printf( "and = %7d ", Aig_ManAndNum(p) );
@@ -453,8 +453,8 @@ void Aig_ManReportImprovement( Aig_Man_t * p, Aig_Man_t * pNew )
void Aig_ManSetRegNum( Aig_Man_t * p, int nRegs )
{
p->nRegs = nRegs;
- p->nTruePis = Aig_ManPiNum(p) - nRegs;
- p->nTruePos = Aig_ManPoNum(p) - nRegs;
+ p->nTruePis = Aig_ManCiNum(p) - nRegs;
+ p->nTruePos = Aig_ManCoNum(p) - nRegs;
Aig_ManSetPioNumbers( p );
}
@@ -471,7 +471,7 @@ void Aig_ManSetRegNum( Aig_Man_t * p, int nRegs )
***********************************************************************/
void Aig_ManFlipFirstPo( Aig_Man_t * p )
{
- Aig_ObjChild0Flip( Aig_ManPo(p, 0) );
+ Aig_ObjChild0Flip( Aig_ManCo(p, 0) );
}
/**Function*************************************************************
diff --git a/src/aig/aig/aigMffc.c b/src/aig/aig/aigMffc.c
index ed0015ac..e577124a 100644
--- a/src/aig/aig/aigMffc.c
+++ b/src/aig/aig/aigMffc.c
@@ -49,7 +49,7 @@ int Aig_NodeDeref_rec( Aig_Obj_t * pNode, unsigned LevelMin, float * pPower, flo
int Counter = 0;
if ( pProbs )
*pPower = 0.0;
- if ( Aig_ObjIsPi(pNode) )
+ if ( Aig_ObjIsCi(pNode) )
return 0;
// consider the first fanin
pFanin = Aig_ObjFanin0(pNode);
@@ -87,7 +87,7 @@ int Aig_NodeRef_rec( Aig_Obj_t * pNode, unsigned LevelMin )
{
Aig_Obj_t * pFanin;
int Counter = 0;
- if ( Aig_ObjIsPi(pNode) )
+ if ( Aig_ObjIsCi(pNode) )
return 0;
// consider the first fanin
pFanin = Aig_ObjFanin0(pNode);
@@ -119,7 +119,7 @@ int Aig_NodeRefLabel_rec( Aig_Man_t * p, Aig_Obj_t * pNode, unsigned LevelMin )
{
Aig_Obj_t * pFanin;
int Counter = 0;
- if ( Aig_ObjIsPi(pNode) )
+ if ( Aig_ObjIsCi(pNode) )
return 0;
Aig_ObjSetTravIdCurrent( p, pNode );
// consider the first fanin
@@ -154,7 +154,7 @@ void Aig_NodeMffcSupp_rec( Aig_Man_t * p, Aig_Obj_t * pNode, unsigned LevelMin,
return;
Aig_ObjSetTravIdCurrent(p, pNode);
// add to the new support nodes
- if ( !fTopmost && pNode != pObjSkip && (Aig_ObjIsPi(pNode) || pNode->nRefs > 0 || pNode->Level <= LevelMin) )
+ if ( !fTopmost && pNode != pObjSkip && (Aig_ObjIsCi(pNode) || pNode->nRefs > 0 || pNode->Level <= LevelMin) )
{
if ( vSupp ) Vec_PtrPush( vSupp, pNode );
return;
@@ -182,7 +182,7 @@ int Aig_NodeMffcSupp( Aig_Man_t * p, Aig_Obj_t * pNode, int LevelMin, Vec_Ptr_t
if ( vSupp ) Vec_PtrClear( vSupp );
if ( !Aig_ObjIsNode(pNode) )
{
- if ( Aig_ObjIsPi(pNode) && vSupp )
+ if ( Aig_ObjIsCi(pNode) && vSupp )
Vec_PtrPush( vSupp, pNode );
return 0;
}
diff --git a/src/aig/aig/aigObj.c b/src/aig/aig/aigObj.c
index 863188f4..51989d0a 100644
--- a/src/aig/aig/aigObj.c
+++ b/src/aig/aig/aigObj.c
@@ -46,9 +46,9 @@ Aig_Obj_t * Aig_ObjCreateCi( Aig_Man_t * p )
{
Aig_Obj_t * pObj;
pObj = Aig_ManFetchMemory( p );
- pObj->Type = AIG_OBJ_PI;
- Vec_PtrPush( p->vPis, pObj );
- p->nObjs[AIG_OBJ_PI]++;
+ pObj->Type = AIG_OBJ_CI;
+ Vec_PtrPush( p->vCis, pObj );
+ p->nObjs[AIG_OBJ_CI]++;
if ( p->pManHaig && p->fCreatePios )
{
p->pManHaig->nRegs++;
@@ -73,10 +73,10 @@ Aig_Obj_t * Aig_ObjCreateCo( Aig_Man_t * p, Aig_Obj_t * pDriver )
{
Aig_Obj_t * pObj;
pObj = Aig_ManFetchMemory( p );
- pObj->Type = AIG_OBJ_PO;
- Vec_PtrPush( p->vPos, pObj );
+ pObj->Type = AIG_OBJ_CO;
+ Vec_PtrPush( p->vCos, pObj );
Aig_ObjConnect( p, pObj, pDriver, NULL );
- p->nObjs[AIG_OBJ_PO]++;
+ p->nObjs[AIG_OBJ_CO]++;
if ( p->pManHaig && p->fCreatePios )
{
pObj->pHaig = Aig_ObjCreateCo( p->pManHaig, Aig_ObjHaig( pDriver ) );
@@ -145,7 +145,7 @@ Aig_Obj_t * Aig_ObjCreate( Aig_Man_t * p, Aig_Obj_t * pGhost )
void Aig_ObjConnect( Aig_Man_t * p, Aig_Obj_t * pObj, Aig_Obj_t * pFan0, Aig_Obj_t * pFan1 )
{
assert( !Aig_IsComplement(pObj) );
- assert( !Aig_ObjIsPi(pObj) );
+ assert( !Aig_ObjIsCi(pObj) );
// add the first fanin
pObj->pFanin0 = pFan0;
pObj->pFanin1 = pFan1;
@@ -252,9 +252,9 @@ void Aig_ObjDelete_rec( Aig_Man_t * p, Aig_Obj_t * pObj, int fFreeTop )
{
Aig_Obj_t * pFanin0, * pFanin1;
assert( !Aig_IsComplement(pObj) );
- if ( Aig_ObjIsConst1(pObj) || Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsConst1(pObj) || Aig_ObjIsCi(pObj) )
return;
- assert( !Aig_ObjIsPo(pObj) );
+ assert( !Aig_ObjIsCo(pObj) );
pFanin0 = Aig_ObjFanin0(pObj);
pFanin1 = Aig_ObjFanin1(pObj);
Aig_ObjDisconnect( p, pObj );
@@ -279,7 +279,7 @@ void Aig_ObjDelete_rec( Aig_Man_t * p, Aig_Obj_t * pObj, int fFreeTop )
***********************************************************************/
void Aig_ObjDeletePo( Aig_Man_t * p, Aig_Obj_t * pObj )
{
- assert( Aig_ObjIsPo(pObj) );
+ assert( Aig_ObjIsCo(pObj) );
Aig_ObjDeref(Aig_ObjFanin0(pObj));
pObj->pFanin0 = NULL;
p->nObjs[pObj->Type]--;
@@ -302,7 +302,7 @@ void Aig_ObjPatchFanin0( Aig_Man_t * p, Aig_Obj_t * pObj, Aig_Obj_t * pFaninNew
{
Aig_Obj_t * pFaninOld;
assert( !Aig_IsComplement(pObj) );
- assert( Aig_ObjIsPo(pObj) );
+ assert( Aig_ObjIsCo(pObj) );
pFaninOld = Aig_ObjFanin0(pObj);
// decrement ref and remove fanout
if ( p->pFanData )
@@ -317,7 +317,7 @@ void Aig_ObjPatchFanin0( Aig_Man_t * p, Aig_Obj_t * pObj, Aig_Obj_t * pFaninNew
Aig_ObjAddFanout( p, Aig_ObjFanin0(pObj), pObj );
Aig_ObjRef( Aig_ObjFanin0(pObj) );
// get rid of old fanin
- if ( !Aig_ObjIsPi(pFaninOld) && !Aig_ObjIsConst1(pFaninOld) && Aig_ObjRefs(pFaninOld) == 0 )
+ if ( !Aig_ObjIsCi(pFaninOld) && !Aig_ObjIsConst1(pFaninOld) && Aig_ObjRefs(pFaninOld) == 0 )
Aig_ObjDelete_rec( p, pFaninOld, 1 );
}
@@ -351,9 +351,9 @@ void Aig_ObjPrint( Aig_Man_t * p, Aig_Obj_t * pObj )
printf( "Node %4d : ", Aig_ObjId(pObj) );
if ( Aig_ObjIsConst1(pObj) )
printf( "constant 1" );
- else if ( Aig_ObjIsPi(pObj) )
+ else if ( Aig_ObjIsCi(pObj) )
printf( "PI" );
- else if ( Aig_ObjIsPo(pObj) )
+ else if ( Aig_ObjIsCo(pObj) )
printf( "PO( %4d%s )", Aig_ObjFanin0(pObj)->Id, (Aig_ObjFaninC0(pObj)? "\'" : " ") );
else if ( Aig_ObjIsBuf(pObj) )
printf( "BUF( %d%s )", Aig_ObjFanin0(pObj)->Id, (Aig_ObjFaninC0(pObj)? "\'" : " ") );
@@ -372,7 +372,7 @@ void Aig_ObjPrint( Aig_Man_t * p, Aig_Obj_t * pObj )
{
printf( " " );
printf( "Node %4d : ", Aig_ObjId(pFanout) );
- if ( Aig_ObjIsPo(pFanout) )
+ if ( Aig_ObjIsCo(pFanout) )
printf( "PO( %4d%s )", Aig_ObjFanin0(pFanout)->Id, (Aig_ObjFaninC0(pFanout)? "\'" : " ") );
else if ( Aig_ObjIsBuf(pFanout) )
printf( "BUF( %d%s )", Aig_ObjFanin0(pFanout)->Id, (Aig_ObjFaninC0(pFanout)? "\'" : " ") );
@@ -422,7 +422,7 @@ void Aig_NodeFixBufferFanins( Aig_Man_t * p, Aig_Obj_t * pObj, int fUpdateLevel
{
Aig_Obj_t * pFanReal0, * pFanReal1, * pResult;
p->nBufFixes++;
- if ( Aig_ObjIsPo(pObj) )
+ if ( Aig_ObjIsCo(pObj) )
{
assert( Aig_ObjIsBuf(Aig_ObjFanin0(pObj)) );
pFanReal0 = Aig_ObjReal_rec( Aig_ObjChild0(pObj) );
@@ -498,9 +498,9 @@ void Aig_ObjReplace( Aig_Man_t * p, Aig_Obj_t * pObjOld, Aig_Obj_t * pObjNew, in
// the object to be replaced cannot be complemented
assert( !Aig_IsComplement(pObjOld) );
// the object to be replaced cannot be a terminal
- assert( !Aig_ObjIsPi(pObjOld) && !Aig_ObjIsPo(pObjOld) );
+ assert( !Aig_ObjIsCi(pObjOld) && !Aig_ObjIsCo(pObjOld) );
// the object to be used cannot be a buffer or a PO
- assert( !Aig_ObjIsBuf(pObjNewR) && !Aig_ObjIsPo(pObjNewR) );
+ assert( !Aig_ObjIsBuf(pObjNewR) && !Aig_ObjIsCo(pObjNewR) );
// the object cannot be the same
assert( pObjOld != pObjNewR );
// make sure object is not pointing to itself
diff --git a/src/aig/aig/aigOper.c b/src/aig/aig/aigOper.c
index 6dd445af..4fe2cd8c 100644
--- a/src/aig/aig/aigOper.c
+++ b/src/aig/aig/aigOper.c
@@ -63,10 +63,10 @@ static inline int Aig_ObjIsExorType( Aig_Obj_t * p0, Aig_Obj_t * p1, Aig_Obj_t *
Aig_Obj_t * Aig_IthVar( Aig_Man_t * p, int i )
{
int v;
- for ( v = Aig_ManPiNum(p); v <= i; v++ )
+ for ( v = Aig_ManCiNum(p); v <= i; v++ )
Aig_ObjCreateCi( p );
- assert( i < Vec_PtrSize(p->vPis) );
- return Aig_ManPi( p, i );
+ assert( i < Vec_PtrSize(p->vCis) );
+ return Aig_ManCi( p, i );
}
/**Function*************************************************************
diff --git a/src/aig/aig/aigPack.c b/src/aig/aig/aigPack.c
index 206f2262..3dcd19b1 100644
--- a/src/aig/aig/aigPack.c
+++ b/src/aig/aig/aigPack.c
@@ -68,8 +68,8 @@ Aig_ManPack_t * Aig_ManPackAlloc( Aig_Man_t * pAig )
p = ABC_CALLOC( Aig_ManPack_t, 1 );
p->pAig = pAig;
p->vSigns = Vec_WrdStart( Aig_ManObjNumMax(pAig) );
- p->vPiPats = Vec_WrdStart( Aig_ManPiNum(pAig) );
- p->vPiCare = Vec_WrdStart( Aig_ManPiNum(pAig) );
+ p->vPiPats = Vec_WrdStart( Aig_ManCiNum(pAig) );
+ p->vPiCare = Vec_WrdStart( Aig_ManCiNum(pAig) );
p->iPatCur = 1;
return p;
}
@@ -137,7 +137,7 @@ void Aig_ManPackFree( Aig_ManPack_t * p )
printf( "Patterns: " );
printf( "Total = %6d. ", p->nPatTotal );
printf( "Skipped = %6d. ", p->nPatSkip );
- printf( "Cares = %6.2f %% ", 100.0*Aig_ManPackCountCares(p)/Aig_ManPiNum(p->pAig)/64 );
+ printf( "Cares = %6.2f %% ", 100.0*Aig_ManPackCountCares(p)/Aig_ManCiNum(p->pAig)/64 );
printf( "\n" );
Vec_WrdFree( p->vSigns );
Vec_WrdFree( p->vPiPats );
diff --git a/src/aig/aig/aigPart.c b/src/aig/aig/aigPart.c
index 2c82264a..587596b5 100644
--- a/src/aig/aig/aigPart.c
+++ b/src/aig/aig/aigPart.c
@@ -286,7 +286,7 @@ Vec_Ptr_t * Aig_ManSupports( Aig_Man_t * pMan )
// start the support computation manager
p = Part_ManStart( 1 << 20, 1 << 6 );
// consider objects in the topological order
- vSupports = Vec_PtrAlloc( Aig_ManPoNum(pMan) );
+ vSupports = Vec_PtrAlloc( Aig_ManCoNum(pMan) );
Aig_ManCleanData(pMan);
Aig_ManForEachObj( pMan, pObj, i )
{
@@ -305,7 +305,7 @@ Vec_Ptr_t * Aig_ManSupports( Aig_Man_t * pMan )
Counter++;
continue;
}
- if ( Aig_ObjIsPo(pObj) )
+ if ( Aig_ObjIsCo(pObj) )
{
pPart0 = (Part_One_t *)Aig_ObjFanin0(pObj)->pData;
vSupp = Part_ManTransferEntry(pPart0);
@@ -316,7 +316,7 @@ Vec_Ptr_t * Aig_ManSupports( Aig_Man_t * pMan )
Part_ManRecycleEntry( p, pPart0 );
continue;
}
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
{
if ( pObj->nRefs )
{
@@ -390,8 +390,8 @@ Vec_Ptr_t * Aig_ManSupportsInverse( Aig_Man_t * p )
// get structural supports for each output
vSupps = Aig_ManSupports( p );
// start the inverse supports
- vSuppsInv = Vec_PtrAlloc( Aig_ManPiNum(p) );
- for ( i = 0; i < Aig_ManPiNum(p); i++ )
+ vSuppsInv = Vec_PtrAlloc( Aig_ManCiNum(p) );
+ for ( i = 0; i < Aig_ManCiNum(p); i++ )
Vec_PtrPush( vSuppsInv, Vec_IntAlloc(8) );
// transforms the supports into the inverse supports
Vec_PtrForEachEntry( Vec_Int_t *, vSupps, vSupp, i )
@@ -428,7 +428,7 @@ Vec_Ptr_t * Aig_ManSupportsRegisters( Aig_Man_t * p )
{
// skip true POs
iOut = Vec_IntPop( vSupp );
- iOut -= Aig_ManPoNum(p) - Aig_ManRegNum(p);
+ iOut -= Aig_ManCoNum(p) - Aig_ManRegNum(p);
if ( iOut < 0 )
{
Vec_IntFree( vSupp );
@@ -438,7 +438,7 @@ Vec_Ptr_t * Aig_ManSupportsRegisters( Aig_Man_t * p )
m = 0;
Vec_IntForEachEntry( vSupp, iIn, k )
{
- iIn -= Aig_ManPiNum(p) - Aig_ManRegNum(p);
+ iIn -= Aig_ManCiNum(p) - Aig_ManRegNum(p);
if ( iIn < 0 )
continue;
assert( iIn < Aig_ManRegNum(p) );
@@ -596,8 +596,8 @@ void Aig_ManPartitionPrint( Aig_Man_t * p, Vec_Ptr_t * vPartsAll, Vec_Ptr_t * vP
if ( i == Vec_PtrSize(vPartsAll) - 1 )
break;
}
- assert( Counter == Aig_ManPoNum(p) );
-// printf( "\nTotal = %d. Outputs = %d.\n", Counter, Aig_ManPoNum(p) );
+ assert( Counter == Aig_ManCoNum(p) );
+// printf( "\nTotal = %d. Outputs = %d.\n", Counter, Aig_ManCoNum(p) );
}
/**Function*************************************************************
@@ -721,7 +721,7 @@ clk = clock();
Vec_PtrPush( vPartsAll, vPart );
Vec_PtrPush( vPartSuppsAll, vPartSupp );
- Vec_PtrPush( vPartSuppsBit, Aig_ManSuppCharStart(vOne, Aig_ManPiNum(p)) );
+ Vec_PtrPush( vPartSuppsBit, Aig_ManSuppCharStart(vOne, Aig_ManCiNum(p)) );
}
else
{
@@ -735,7 +735,7 @@ clk = clock();
// reinsert new support
Vec_PtrWriteEntry( vPartSuppsAll, iPart, vPartSupp );
- Aig_ManSuppCharAdd( (unsigned *)Vec_PtrEntry(vPartSuppsBit, iPart), vOne, Aig_ManPiNum(p) );
+ Aig_ManSuppCharAdd( (unsigned *)Vec_PtrEntry(vPartSuppsBit, iPart), vOne, Aig_ManCiNum(p) );
}
}
@@ -788,7 +788,7 @@ if ( fVerbose )
{
vPartPtr = Vec_PtrAlloc( Vec_IntSize(vPart) );
Vec_IntForEachEntry( vPart, iOut, i )
- Vec_PtrPush( vPartPtr, Aig_ManPo(p, iOut) );
+ Vec_PtrPush( vPartPtr, Aig_ManCo(p, iOut) );
Vec_IntFree( vPart );
Vec_PtrWriteEntry( vPartsAll, iPart, vPartPtr );
}
@@ -917,7 +917,7 @@ if ( fVerbose )
{
vPartPtr = Vec_PtrAlloc( Vec_IntSize(vPart) );
Vec_IntForEachEntry( vPart, iOut, i )
- Vec_PtrPush( vPartPtr, Aig_ManPo(p, iOut) );
+ Vec_PtrPush( vPartPtr, Aig_ManCo(p, iOut) );
Vec_IntFree( vPart );
Vec_PtrWriteEntry( vPartsAll, iPart, vPartPtr );
}
@@ -941,7 +941,7 @@ Vec_Ptr_t * Aig_ManPartitionNaive( Aig_Man_t * p, int nPartSize )
Vec_Ptr_t * vParts;
Aig_Obj_t * pObj;
int nParts, i;
- nParts = (Aig_ManPoNum(p) / nPartSize) + ((Aig_ManPoNum(p) % nPartSize) > 0);
+ nParts = (Aig_ManCoNum(p) / nPartSize) + ((Aig_ManCoNum(p) % nPartSize) > 0);
vParts = (Vec_Ptr_t *)Vec_VecStart( nParts );
Aig_ManForEachCo( p, pObj, i )
Vec_IntPush( (Vec_Int_t *)Vec_PtrEntry(vParts, i / nPartSize), i );
@@ -967,9 +967,9 @@ Aig_Obj_t * Aig_ManDupPart_rec( Aig_Man_t * pNew, Aig_Man_t * pOld, Aig_Obj_t *
if ( Aig_ObjIsTravIdCurrent(pOld, pObj) )
return (Aig_Obj_t *)pObj->pData;
Aig_ObjSetTravIdCurrent(pOld, pObj);
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
{
- assert( Vec_IntSize(vSuppMap) == Aig_ManPiNum(pNew) );
+ assert( Vec_IntSize(vSuppMap) == Aig_ManCiNum(pNew) );
Vec_IntPush( vSuppMap, (int)(long)pObj->pNext );
return (Aig_Obj_t *)(pObj->pData = Aig_ObjCreateCi(pNew));
}
@@ -1003,8 +1003,8 @@ Vec_Ptr_t * Aig_ManDupPart( Aig_Man_t * pNew, Aig_Man_t * pOld, Vec_Int_t * vPar
{
Vec_IntForEachEntry( vSuppMap, Entry, i )
{
- pObj = Aig_ManPi( pOld, Entry );
- pObj->pData = Aig_ManPi( pNew, i );
+ pObj = Aig_ManCi( pOld, Entry );
+ pObj->pData = Aig_ManCi( pNew, i );
Aig_ObjSetTravIdCurrent( pOld, pObj );
}
}
@@ -1012,8 +1012,8 @@ Vec_Ptr_t * Aig_ManDupPart( Aig_Man_t * pNew, Aig_Man_t * pOld, Vec_Int_t * vPar
{
Vec_IntForEachEntry( vSuppMap, Entry, i )
{
- pObj = Aig_ManPi( pOld, i );
- pObj->pData = Aig_ManPi( pNew, Entry );
+ pObj = Aig_ManCi( pOld, i );
+ pObj->pData = Aig_ManCi( pNew, Entry );
Aig_ObjSetTravIdCurrent( pOld, pObj );
}
vSuppMap = NULL; // should not be useful
@@ -1024,7 +1024,7 @@ Vec_Ptr_t * Aig_ManDupPart( Aig_Man_t * pNew, Aig_Man_t * pOld, Vec_Int_t * vPar
{
Vec_IntForEachEntry( vPart, Entry, i )
{
- pObj = Aig_ManPo( pOld, Entry );
+ pObj = Aig_ManCo( pOld, Entry );
Aig_ManDupPart_rec( pNew, pOld, Aig_ObjFanin0(pObj), vSuppMap );
Vec_PtrPush( vOutsTotal, Aig_ObjChild0Copy(pObj) );
}
@@ -1033,7 +1033,7 @@ Vec_Ptr_t * Aig_ManDupPart( Aig_Man_t * pNew, Aig_Man_t * pOld, Vec_Int_t * vPar
{
Aig_ManForEachObj( pOld, pObj, i )
{
- if ( Aig_ObjIsPo(pObj) )
+ if ( Aig_ObjIsCo(pObj) )
{
Aig_ManDupPart_rec( pNew, pOld, Aig_ObjFanin0(pObj), vSuppMap );
Vec_PtrPush( vOutsTotal, Aig_ObjChild0Copy(pObj) );
@@ -1064,9 +1064,9 @@ void Aig_ManDupPartAll_rec( Aig_Man_t * pNew, Aig_Man_t * pOld, Aig_Obj_t * pObj
if ( Aig_ObjIsTravIdCurrent(pOld, pObj) )
return;
Aig_ObjSetTravIdCurrent(pOld, pObj);
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
pObjNew = Aig_ObjCreateCi(pNew);
- else if ( Aig_ObjIsPo(pObj) )
+ else if ( Aig_ObjIsCo(pObj) )
{
Aig_ManDupPartAll_rec( pNew, pOld, Aig_ObjFanin0(pObj) );
pObjNew = Aig_ObjCreateCo( pNew, Aig_ObjChild0Copy(pObj) );
@@ -1109,7 +1109,7 @@ Aig_Man_t * Aig_ManDupPartAll( Aig_Man_t * pOld, Vec_Int_t * vPart )
// map all other nodes
Vec_IntForEachEntry( vPart, Entry, i )
{
- pObj = Aig_ManPo( pOld, Entry );
+ pObj = Aig_ManCo( pOld, Entry );
Aig_ManDupPartAll_rec( pNew, pOld, pObj );
}
return pNew;
@@ -1131,7 +1131,7 @@ void Aig_ManSupportNodes_rec( Aig_Man_t * p, Aig_Obj_t * pObj, Vec_Int_t * vSupp
if ( Aig_ObjIsTravIdCurrent(p, pObj) )
return;
Aig_ObjSetTravIdCurrent(p, pObj);
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
{
Vec_IntPush( vSupport, Aig_ObjPioNum(pObj) );
return;
@@ -1164,7 +1164,7 @@ Vec_Ptr_t * Aig_ManSupportNodes( Aig_Man_t * p, Vec_Ptr_t * vParts )
Aig_ManIncrementTravId( p );
Aig_ObjSetTravIdCurrent( p, Aig_ManConst1(p) );
Vec_IntForEachEntry( vPart, iOut, k )
- Aig_ManSupportNodes_rec( p, Aig_ObjFanin0(Aig_ManPo(p, iOut)), vSupport );
+ Aig_ManSupportNodes_rec( p, Aig_ObjFanin0(Aig_ManCo(p, iOut)), vSupport );
// Vec_IntSort( vSupport, 0 );
Vec_PtrPush( vPartSupps, vSupport );
}
@@ -1270,7 +1270,7 @@ Aig_Man_t * Aig_ManChoicePartitioned( Vec_Ptr_t * vAigs, int nPartSize, int nCon
// start the total fraiged AIG
pAigTotal = Aig_ManStartFrom( pAig );
Aig_ManReprStart( pAigTotal, nIdMax );
- vOutsTotal = Vec_PtrStart( Aig_ManPoNum(pAig) );
+ vOutsTotal = Vec_PtrStart( Aig_ManCoNum(pAig) );
// set the PI numbers
Vec_PtrForEachEntry( Aig_Man_t *, vAigs, pAig, i )
@@ -1313,7 +1313,7 @@ Aig_Man_t * Aig_ManChoicePartitioned( Vec_Ptr_t * vAigs, int nPartSize, int nCon
// report the process
if ( fVerbose )
printf( "Part %4d (out of %4d) PI = %5d. PO = %5d. And = %6d. Lev = %4d.\r",
- i+1, Vec_PtrSize(vParts), Aig_ManPiNum(pAigPart), Aig_ManPoNum(pAigPart),
+ i+1, Vec_PtrSize(vParts), Aig_ManCiNum(pAigPart), Aig_ManCoNum(pAigPart),
Aig_ManNodeNum(pAigPart), Aig_ManLevelNum(pAigPart) );
// compute equivalence classes (to be stored in pNew->pReprs)
pAig = Fra_FraigChoice( pAigPart, nConfMax, nLevelMax );
@@ -1406,7 +1406,7 @@ Aig_Man_t * Aig_ManFraigPartitioned( Aig_Man_t * pAig, int nPartSize, int nConfM
// report the process
if ( fVerbose )
printf( "Part %4d (out of %4d) PI = %5d. PO = %5d. And = %6d. Lev = %4d.\r",
- i+1, Vec_PtrSize(vParts), Aig_ManPiNum(pAigPart), Aig_ManPoNum(pAigPart),
+ i+1, Vec_PtrSize(vParts), Aig_ManCiNum(pAigPart), Aig_ManCoNum(pAigPart),
Aig_ManNodeNum(pAigPart), Aig_ManLevelNum(pAigPart) );
// compute equivalence classes (to be stored in pNew->pReprs)
pAigTemp = Fra_FraigChoice( pAigPart, nConfMax, nLevelMax );
@@ -1477,10 +1477,10 @@ void Aig_ManChoiceConstructiveOne( Aig_Man_t * pNew, Aig_Man_t * pPrev, Aig_Man_
{
Aig_Obj_t * pObj, * pObjNew;
int i;
- assert( Aig_ManPiNum(pNew) == Aig_ManPiNum(pPrev) );
- assert( Aig_ManPiNum(pNew) == Aig_ManPiNum(pThis) );
- assert( Aig_ManPoNum(pNew) == Aig_ManPoNum(pPrev) );
- assert( Aig_ManPoNum(pNew) == Aig_ManPoNum(pThis) );
+ assert( Aig_ManCiNum(pNew) == Aig_ManCiNum(pPrev) );
+ assert( Aig_ManCiNum(pNew) == Aig_ManCiNum(pThis) );
+ assert( Aig_ManCoNum(pNew) == Aig_ManCoNum(pPrev) );
+ assert( Aig_ManCoNum(pNew) == Aig_ManCoNum(pThis) );
// make sure the nodes of pPrev point to pNew
Aig_ManForEachObj( pNew, pObj, i )
pObj->fMarkB = 1;
@@ -1499,9 +1499,9 @@ void Aig_ManChoiceConstructiveOne( Aig_Man_t * pNew, Aig_Man_t * pPrev, Aig_Man_
pObj = Aig_ManConst1(pThis);
pObj->pData = Aig_ManConst1(pNew);
Aig_ManForEachCi( pThis, pObj, i )
- pObj->pData = Aig_ManPi(pNew, i);
+ pObj->pData = Aig_ManCi(pNew, i);
Aig_ManForEachCo( pThis, pObj, i )
- pObj->pData = Aig_ManPo(pNew, i);
+ pObj->pData = Aig_ManCo(pNew, i);
// go through the nodes in the topological order
Aig_ManForEachNode( pThis, pObj, i )
{
@@ -1514,7 +1514,7 @@ void Aig_ManChoiceConstructiveOne( Aig_Man_t * pNew, Aig_Man_t * pPrev, Aig_Man_
// set the inputs of POs as equivalent
Aig_ManForEachCo( pThis, pObj, i )
{
- pObjNew = Aig_ObjFanin0( Aig_ManPo(pNew,i) );
+ pObjNew = Aig_ObjFanin0( Aig_ManCo(pNew,i) );
// pObjNew and Aig_ObjFanin0(pObj)->pData are equivalent
Aig_ObjSetRepr_( pNew, pObjNew, Aig_Regular((Aig_Obj_t *)Aig_ObjFanin0(pObj)->pData) );
}
diff --git a/src/aig/aig/aigPartReg.c b/src/aig/aig/aigPartReg.c
index ca2e9602..b5064900 100644
--- a/src/aig/aig/aigPartReg.c
+++ b/src/aig/aig/aigPartReg.c
@@ -255,13 +255,13 @@ Vec_Ptr_t * Aig_ManRegProjectOnehots( Aig_Man_t * pAig, Aig_Man_t * pPart, Vec_P
Aig_ManForEachCi( pPart, pObj, i )
pObj->iData = i;
// go through each group and check if registers are involved in this one
- nOffset = Aig_ManPiNum(pAig)-Aig_ManRegNum(pAig);
+ nOffset = Aig_ManCiNum(pAig)-Aig_ManRegNum(pAig);
Vec_PtrForEachEntry( Vec_Int_t *, vOnehots, vGroup, i )
{
vGroupNew = NULL;
Vec_IntForEachEntry( vGroup, iReg, k )
{
- pObj = Aig_ManPi( pAig, nOffset+iReg );
+ pObj = Aig_ManCi( pAig, nOffset+iReg );
if ( !Aig_ObjIsTravIdCurrent(pAig, pObj) )
continue;
if ( vGroupNew == NULL )
@@ -316,20 +316,20 @@ Aig_Man_t * Aig_ManRegCreatePart( Aig_Man_t * pAig, Vec_Int_t * vPart, int * pnC
int * pMapBack;
// collect roots
vRoots = Vec_PtrAlloc( Vec_IntSize(vPart) );
- nOffset = Aig_ManPoNum(pAig)-Aig_ManRegNum(pAig);
+ nOffset = Aig_ManCoNum(pAig)-Aig_ManRegNum(pAig);
Vec_IntForEachEntry( vPart, iOut, i )
{
- pObj = Aig_ManPo(pAig, nOffset+iOut);
+ pObj = Aig_ManCo(pAig, nOffset+iOut);
Vec_PtrPush( vRoots, Aig_ObjFanin0(pObj) );
}
// collect/mark nodes/PIs in the DFS order
vNodes = Aig_ManDfsNodes( pAig, (Aig_Obj_t **)Vec_PtrArray(vRoots), Vec_PtrSize(vRoots) );
Vec_PtrFree( vRoots );
// unmark register outputs
- nOffset = Aig_ManPiNum(pAig)-Aig_ManRegNum(pAig);
+ nOffset = Aig_ManCiNum(pAig)-Aig_ManRegNum(pAig);
Vec_IntForEachEntry( vPart, iOut, i )
{
- pObj = Aig_ManPi(pAig, nOffset+iOut);
+ pObj = Aig_ManCi(pAig, nOffset+iOut);
Aig_ObjSetTravIdPrevious( pAig, pObj );
}
// count pure PIs
@@ -352,10 +352,10 @@ Aig_Man_t * Aig_ManRegCreatePart( Aig_Man_t * pAig, Vec_Int_t * vPart, int * pnC
pObj->pData = Aig_ObjCreateCi(pNew);
// add variables for the register outputs
// create fake POs to hold the register outputs
- nOffset = Aig_ManPiNum(pAig)-Aig_ManRegNum(pAig);
+ nOffset = Aig_ManCiNum(pAig)-Aig_ManRegNum(pAig);
Vec_IntForEachEntry( vPart, iOut, i )
{
- pObj = Aig_ManPi(pAig, nOffset+iOut);
+ pObj = Aig_ManCi(pAig, nOffset+iOut);
pObj->pData = Aig_ObjCreateCi(pNew);
Aig_ObjCreateCo( pNew, (Aig_Obj_t *)pObj->pData );
Aig_ObjSetTravIdCurrent( pAig, pObj ); // added
@@ -365,10 +365,10 @@ Aig_Man_t * Aig_ManRegCreatePart( Aig_Man_t * pAig, Vec_Int_t * vPart, int * pnC
if ( Aig_ObjIsNode(pObj) )
pObj->pData = Aig_And(pNew, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj) );
// add real POs for the registers
- nOffset = Aig_ManPoNum(pAig)-Aig_ManRegNum(pAig);
+ nOffset = Aig_ManCoNum(pAig)-Aig_ManRegNum(pAig);
Vec_IntForEachEntry( vPart, iOut, i )
{
- pObj = Aig_ManPo( pAig, nOffset+iOut );
+ pObj = Aig_ManCo( pAig, nOffset+iOut );
Aig_ObjCreateCo( pNew, Aig_ObjChild0Copy(pObj) );
}
pNew->nRegs = Vec_IntSize(vPart);
@@ -386,10 +386,10 @@ Aig_Man_t * Aig_ManRegCreatePart( Aig_Man_t * pAig, Vec_Int_t * vPart, int * pnC
pMapBack[pObjNew->Id] = pObj->Id;
}
// map register outputs
- nOffset = Aig_ManPiNum(pAig)-Aig_ManRegNum(pAig);
+ nOffset = Aig_ManCiNum(pAig)-Aig_ManRegNum(pAig);
Vec_IntForEachEntry( vPart, iOut, i )
{
- pObj = Aig_ManPi(pAig, nOffset+iOut);
+ pObj = Aig_ManCi(pAig, nOffset+iOut);
pObjNew = (Aig_Obj_t *)pObj->pData;
pMapBack[pObjNew->Id] = pObj->Id;
}
@@ -551,12 +551,12 @@ void Aig_ManRegPartitionTraverse_rec( Aig_Man_t * p, Aig_Obj_t * pObj, Vec_Ptr_t
if ( Aig_ObjIsTravIdCurrent(p, pObj) )
return;
Aig_ObjSetTravIdCurrent( p, pObj );
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
{
- if ( pObj->iData >= Aig_ManPiNum(p) - Aig_ManRegNum(p) )
+ if ( pObj->iData >= Aig_ManCiNum(p) - Aig_ManRegNum(p) )
{
Vec_PtrPush( vLos, pObj );
- printf( "%d ", pObj->iData - (Aig_ManPiNum(p) - Aig_ManRegNum(p)) );
+ printf( "%d ", pObj->iData - (Aig_ManCiNum(p) - Aig_ManRegNum(p)) );
}
return;
}
diff --git a/src/aig/aig/aigPartSat.c b/src/aig/aig/aigPartSat.c
index 701273a3..839a17ee 100644
--- a/src/aig/aig/aigPartSat.c
+++ b/src/aig/aig/aigPartSat.c
@@ -247,7 +247,7 @@ Vec_Ptr_t * Aig_ManPartSplit( Aig_Man_t * p, Vec_Int_t * vNode2Part, Vec_Ptr_t *
Aig_ManForEachCo( p, pObj, i )
{
pDriver = Aig_ObjFanin0(pObj);
- if ( Aig_ObjIsPi(pDriver) )
+ if ( Aig_ObjIsCi(pDriver) )
{
if ( Aig_ObjFaninC0(pObj) )
pDriver->fMarkA = 1; // const0 PI
@@ -275,7 +275,7 @@ Vec_Ptr_t * Aig_ManPartSplit( Aig_Man_t * p, Vec_Int_t * vNode2Part, Vec_Ptr_t *
Aig_ManForEachCo( p, pObj, i )
{
pDriver = Aig_ObjFanin0(pObj);
- if ( Aig_ObjIsPi(pDriver) )
+ if ( Aig_ObjIsCi(pDriver) )
pDriver->fMarkA = pDriver->fMarkB = 0;
else
Vec_VecPush( vPart2Pos, Vec_IntEntry(vNode2Part, Aig_ObjFaninId0(pObj)), pObj );
@@ -330,7 +330,7 @@ void Aig_ManPartSetNodePolarity( Aig_Man_t * p, Aig_Man_t * pPart, Vec_Int_t * v
pObj->fPhase = (Aig_ObjFanin0(pObj)->fPhase ^ Aig_ObjFaninC0(pObj)) & (Aig_ObjFanin1(pObj)->fPhase ^ Aig_ObjFaninC1(pObj));
Aig_ManForEachCo( pPart, pObj, i )
{
- pObjInit = Aig_ManObj( p, Vec_IntEntry(vPio2Id, Aig_ManPiNum(pPart) + i) );
+ pObjInit = Aig_ManObj( p, Vec_IntEntry(vPio2Id, Aig_ManCiNum(pPart) + i) );
pObj->fPhase = (Aig_ObjFanin0(pObj)->fPhase ^ Aig_ObjFaninC0(pObj));
assert( pObj->fPhase == pObjInit->fPhase );
}
@@ -354,7 +354,7 @@ void Aig_ManDeriveCounterExample( Aig_Man_t * p, Vec_Int_t * vNode2Var, sat_solv
int i;
// collect IDs of PI variables
// (fanoutless PIs have SAT var 0, which is an unused in the SAT solver -> has value 0)
- vPisIds = Vec_IntAlloc( Aig_ManPiNum(p) );
+ vPisIds = Vec_IntAlloc( Aig_ManCiNum(p) );
Aig_ManForEachCi( p, pObj, i )
Vec_IntPush( vPisIds, Vec_IntEntry(vNode2Var, Aig_ObjId(pObj)) );
// derive the SAT assignment
@@ -383,7 +383,7 @@ int Aig_ManAddNewCnfToSolver( sat_solver * pSat, Aig_Man_t * pAig, Vec_Int_t * v
int * pBeg, * pEnd;
int i, Lits[2], iSatVarOld, iNodeIdOld;
// derive CNF and express it using new SAT variables
- pCnf = Cnf_Derive( pAig, Aig_ManPoNum(pAig) );
+ pCnf = Cnf_Derive( pAig, Aig_ManCoNum(pAig) );
Cnf_DataTranformPolarity( pCnf, 1 );
Cnf_DataLift( pCnf, sat_solver_nvars(pSat) );
// create new variables in the SAT solver
@@ -419,7 +419,7 @@ int Aig_ManAddNewCnfToSolver( sat_solver * pSat, Aig_Man_t * pAig, Vec_Int_t * v
// derive the connector clauses
Aig_ManForEachCo( pAig, pObj, i )
{
- iNodeIdOld = Vec_IntEntry( vPioIds, Aig_ManPiNum(pAig) + i );
+ iNodeIdOld = Vec_IntEntry( vPioIds, Aig_ManCiNum(pAig) + i );
iSatVarOld = Vec_IntEntry( vNode2Var, iNodeIdOld );
if ( iSatVarOld == 0 ) // iNodeIdOld in the original AIG has no SAT var
{
diff --git a/src/aig/aig/aigRepar.c b/src/aig/aig/aigRepar.c
index 2b17cde6..1b017346 100644
--- a/src/aig/aig/aigRepar.c
+++ b/src/aig/aig/aigRepar.c
@@ -131,7 +131,7 @@ void Aig_ManInterTest( Aig_Man_t * pMan, int fVerbose )
int Lit, Cid, Var, status, i;
int clk = clock();
assert( Aig_ManRegNum(pMan) == 0 );
- assert( Aig_ManPoNum(pMan) == 1 );
+ assert( Aig_ManCoNum(pMan) == 1 );
// derive CNFs
pCnf = Cnf_Derive( pMan, 1 );
@@ -144,7 +144,7 @@ void Aig_ManInterTest( Aig_Man_t * pMan, int fVerbose )
{
if ( pCnf->pVarNums[pObj->Id] < 0 )
continue;
- if ( !Aig_ObjIsPi(pObj) && !Aig_ObjIsPo(pObj) )
+ if ( !Aig_ObjIsCi(pObj) && !Aig_ObjIsCo(pObj) )
var_set_partA( pSat, pCnf->pVarNums[pObj->Id], 1 );
}
@@ -162,7 +162,7 @@ void Aig_ManInterTest( Aig_Man_t * pMan, int fVerbose )
Cnf_DataLift( pCnf, -pCnf->nVars );
// add PI equality clauses
- vVars = Vec_IntAlloc( Aig_ManPoNum(pMan)+1 );
+ vVars = Vec_IntAlloc( Aig_ManCoNum(pMan)+1 );
Aig_ManForEachCi( pMan, pObj, i )
{
if ( Aig_ObjRefs(pObj) == 0 )
@@ -173,7 +173,7 @@ void Aig_ManInterTest( Aig_Man_t * pMan, int fVerbose )
}
// add an XOR clause in the end
- Var = pCnf->pVarNums[Aig_ManPo(pMan,0)->Id];
+ Var = pCnf->pVarNums[Aig_ManCo(pMan,0)->Id];
Aig_ManInterAddXor( pSat, Var, pCnf->nVars + Var, 2*pCnf->nVars, 0, 0 );
Vec_IntPush( vVars, Var );
@@ -215,8 +215,8 @@ void Aig_ManAppend( Aig_Man_t * pBase, Aig_Man_t * pNew )
{
Aig_Obj_t * pObj;
int i;
- assert( Aig_ManPoNum(pNew) == 1 );
- assert( Aig_ManPiNum(pNew) == Aig_ManPiNum(pBase) );
+ assert( Aig_ManCoNum(pNew) == 1 );
+ assert( Aig_ManCiNum(pNew) == Aig_ManCiNum(pBase) );
// create the PIs
Aig_ManCleanData( pNew );
Aig_ManConst1(pNew)->pData = Aig_ManConst1(pBase);
@@ -226,7 +226,7 @@ void Aig_ManAppend( Aig_Man_t * pBase, Aig_Man_t * pNew )
Aig_ManForEachNode( pNew, pObj, i )
pObj->pData = Aig_And( pBase, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj) );
// add one PO to base
- pObj = Aig_ManPo( pNew, 0 );
+ pObj = Aig_ManCo( pNew, 0 );
Aig_ObjCreateCo( pBase, Aig_ObjChild0Copy(pObj) );
}
@@ -248,7 +248,7 @@ Aig_Man_t * Aig_ManInterRepar( Aig_Man_t * pMan, int fVerbose )
Vec_Int_t * vVars;
Cnf_Dat_t * pCnf, * pCnfInter;
Aig_Obj_t * pObj;
- int nOuts = Aig_ManPoNum(pMan);
+ int nOuts = Aig_ManCoNum(pMan);
int ShiftP[2], ShiftCnf[2], ShiftOr[2], ShiftAssume;
int Cid, Lit, status, i, k, c;
int clk = clock();
@@ -369,7 +369,7 @@ Aig_Man_t * Aig_ManInterRepar( Aig_Man_t * pMan, int fVerbose )
if ( i <= k )
Aig_ManInterAddBuffer( pSat, i, pCnf->pVarNums[pObj->Id], 0, c==0 );
// connect to the outputs
- pObj = Aig_ManPo(pInter, 0);
+ pObj = Aig_ManCo(pInter, 0);
Aig_ManInterAddBuffer( pSat, ShiftP[c] + k, pCnf->pVarNums[pObj->Id], 0, c==0 );
if ( c == 1 )
Cnf_DataLift( pCnfInter, -pCnfInter->nVars );
diff --git a/src/aig/aig/aigRepr.c b/src/aig/aig/aigRepr.c
index 5063d559..f43b7edd 100644
--- a/src/aig/aig/aigRepr.c
+++ b/src/aig/aig/aigRepr.c
@@ -401,7 +401,7 @@ int Aig_ObjCheckTfi_rec( Aig_Man_t * p, Aig_Obj_t * pNode, Aig_Obj_t * pOld )
// check the trivial cases
if ( pNode == NULL )
return 0;
- if ( Aig_ObjIsPi(pNode) )
+ if ( Aig_ObjIsCi(pNode) )
return 0;
// if ( pNode->Id < pOld->Id ) // cannot use because of choices of pNode
// return 0;
diff --git a/src/aig/aig/aigRet.c b/src/aig/aig/aigRet.c
index d96e209e..58a04fb0 100644
--- a/src/aig/aig/aigRet.c
+++ b/src/aig/aig/aigRet.c
@@ -307,8 +307,8 @@ Rtm_Man_t * Rtm_ManAlloc( Aig_Man_t * p )
memset( pRtm, 0, sizeof(Rtm_Man_t) );
// perform initializations
pRtm->vObjs = Vec_PtrAlloc( Aig_ManObjNum(p) );
- pRtm->vPis = Vec_PtrAlloc( Aig_ManPiNum(p) );
- pRtm->vPos = Vec_PtrAlloc( Aig_ManPoNum(p) );
+ pRtm->vPis = Vec_PtrAlloc( Aig_ManCiNum(p) );
+ pRtm->vPos = Vec_PtrAlloc( Aig_ManCoNum(p) );
pRtm->pMem = Aig_MmFlexStart();
return pRtm;
}
@@ -742,7 +742,7 @@ Aig_Obj_t * Rtm_ManToAig_rec( Aig_Man_t * pNew, Rtm_Man_t * pRtm, Rtm_Obj_t * pO
else
{
Val = Rtm_ObjGetFirst( pRtm, pEdge );
- pFanin = Aig_ManPi( pNew, pLatches[2*pObjRtm->Id + k] + pEdge->nLats - 1 );
+ pFanin = Aig_ManCi( pNew, pLatches[2*pObjRtm->Id + k] + pEdge->nLats - 1 );
pFanin = Aig_NotCond( pFanin, Val == RTM_VAL_ONE );
}
pFanin = Aig_NotCond( pFanin, k ? pObjRtm->fCompl1 : pObjRtm->fCompl0 );
@@ -806,7 +806,7 @@ Aig_Man_t * Rtm_ManToAig( Rtm_Man_t * pRtm )
assert( Val == RTM_VAL_ZERO || Val == RTM_VAL_ONE || Val == RTM_VAL_VOID );
pObjNew = Aig_NotCond( pObjNew, Val == RTM_VAL_ONE );
Aig_ObjCreateCo( pNew, pObjNew );
- pObjNew = Aig_ManPi( pNew, pLatches[2*pObjRtm->Id + k] + m );
+ pObjNew = Aig_ManCi( pNew, pLatches[2*pObjRtm->Id + k] + m );
pObjNew = Aig_NotCond( pObjNew, Val == RTM_VAL_ONE );
}
// assert( Aig_Regular(pObjNew)->nRefs > 0 );
diff --git a/src/aig/aig/aigRetF.c b/src/aig/aig/aigRetF.c
index 567f6468..05fba120 100644
--- a/src/aig/aig/aigRetF.c
+++ b/src/aig/aig/aigRetF.c
@@ -46,7 +46,7 @@ int Aig_ManRetimeMark_rec( Aig_Man_t * p, Aig_Obj_t * pObj )
{
if ( pObj->fMarkB )
return 1;
- if ( Aig_ObjIsPi(pObj) || Aig_ObjIsConst1(pObj) )
+ if ( Aig_ObjIsCi(pObj) || Aig_ObjIsConst1(pObj) )
return 0;
if ( Aig_ObjIsTravIdCurrent(p, pObj) )
return pObj->fMarkB;
diff --git a/src/aig/aig/aigScl.c b/src/aig/aig/aigScl.c
index dcae3eb7..26de9244 100644
--- a/src/aig/aig/aigScl.c
+++ b/src/aig/aig/aigScl.c
@@ -65,7 +65,7 @@ Aig_Man_t * Aig_ManRemap( Aig_Man_t * p, Vec_Ptr_t * vMap )
Aig_ManForEachCi( p, pObj, i )
pObj->pData = Aig_ObjCreateCi(pNew);
// implement the mapping
- nTruePis = Aig_ManPiNum(p)-Aig_ManRegNum(p);
+ nTruePis = Aig_ManCiNum(p)-Aig_ManRegNum(p);
if ( p->vFlopReprs )
{
Aig_ManForEachLoSeq( p, pObj, i )
@@ -83,7 +83,7 @@ Aig_Man_t * Aig_ManRemap( Aig_Man_t * p, Vec_Ptr_t * vMap )
else
{
assert( !Aig_IsComplement(pObjMapped) );
- assert( Aig_ObjIsPi(pObjMapped) );
+ assert( Aig_ObjIsCi(pObjMapped) );
assert( Aig_ObjPioNum(pObj) != Aig_ObjPioNum(pObjMapped) );
Vec_IntPush( pNew->vFlopReprs, Aig_ObjPioNum(pObjMapped) );
}
@@ -128,12 +128,12 @@ void Aig_ManSeqCleanup_rec( Aig_Man_t * p, Aig_Obj_t * pObj, Vec_Ptr_t * vNodes
return;
Aig_ObjSetTravIdCurrent(p, pObj);
// collect latch input corresponding to unmarked PI (latch output)
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
{
Vec_PtrPush( vNodes, pObj->pNext );
return;
}
- if ( Aig_ObjIsPo(pObj) || Aig_ObjIsBuf(pObj) )
+ if ( Aig_ObjIsCo(pObj) || Aig_ObjIsBuf(pObj) )
{
Aig_ManSeqCleanup_rec( p, Aig_ObjFanin0(pObj), vNodes );
return;
@@ -178,17 +178,17 @@ int Aig_ManSeqCleanup( Aig_Man_t * p )
// mark the nodes reachable from these nodes
Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
Aig_ManSeqCleanup_rec( p, pObj, vNodes );
- assert( Vec_PtrSize(vNodes) <= Aig_ManPoNum(p) );
+ assert( Vec_PtrSize(vNodes) <= Aig_ManCoNum(p) );
// clean latch output pointers
Aig_ManForEachLiLoSeq( p, pObjLi, pObjLo, i )
pObjLo->pNext = NULL;
// if some latches are removed, update PIs/POs
- if ( Vec_PtrSize(vNodes) < Aig_ManPoNum(p) )
+ if ( Vec_PtrSize(vNodes) < Aig_ManCoNum(p) )
{
if ( p->vFlopNums )
{
- int nTruePos = Aig_ManPoNum(p)-Aig_ManRegNum(p);
+ int nTruePos = Aig_ManCoNum(p)-Aig_ManRegNum(p);
int iNum, k = 0;
Aig_ManForEachCo( p, pObj, i )
if ( i >= nTruePos && Aig_ObjIsTravIdCurrent(p, pObj) )
@@ -200,7 +200,7 @@ int Aig_ManSeqCleanup( Aig_Man_t * p )
Vec_IntShrink( p->vFlopNums, k );
}
// collect new CIs/COs
- vCis = Vec_PtrAlloc( Aig_ManPiNum(p) );
+ vCis = Vec_PtrAlloc( Aig_ManCiNum(p) );
Aig_ManForEachCi( p, pObj, i )
if ( Aig_ObjIsTravIdCurrent(p, pObj) )
Vec_PtrPush( vCis, pObj );
@@ -209,7 +209,7 @@ int Aig_ManSeqCleanup( Aig_Man_t * p )
Vec_PtrWriteEntry( p->vObjs, pObj->Id, NULL );
// Aig_ManRecycleMemory( p, pObj );
}
- vCos = Vec_PtrAlloc( Aig_ManPoNum(p) );
+ vCos = Vec_PtrAlloc( Aig_ManCoNum(p) );
Aig_ManForEachCo( p, pObj, i )
if ( Aig_ObjIsTravIdCurrent(p, pObj) )
Vec_PtrPush( vCos, pObj );
@@ -220,22 +220,22 @@ int Aig_ManSeqCleanup( Aig_Man_t * p )
// Aig_ManRecycleMemory( p, pObj );
}
// remember the number of true PIs/POs
- nTruePis = Aig_ManPiNum(p) - Aig_ManRegNum(p);
- nTruePos = Aig_ManPoNum(p) - Aig_ManRegNum(p);
+ nTruePis = Aig_ManCiNum(p) - Aig_ManRegNum(p);
+ nTruePos = Aig_ManCoNum(p) - Aig_ManRegNum(p);
// set the new number of registers
- p->nRegs -= Aig_ManPoNum(p) - Vec_PtrSize(vNodes);
+ p->nRegs -= Aig_ManCoNum(p) - Vec_PtrSize(vNodes);
// create new PIs/POs
assert( Vec_PtrSize(vCis) == nTruePis + p->nRegs );
assert( Vec_PtrSize(vCos) == nTruePos + p->nRegs );
- Vec_PtrFree( p->vPis ); p->vPis = vCis;
- Vec_PtrFree( p->vPos ); p->vPos = vCos;
- p->nObjs[AIG_OBJ_PI] = Vec_PtrSize( p->vPis );
- p->nObjs[AIG_OBJ_PO] = Vec_PtrSize( p->vPos );
+ Vec_PtrFree( p->vCis ); p->vCis = vCis;
+ Vec_PtrFree( p->vCos ); p->vCos = vCos;
+ p->nObjs[AIG_OBJ_CI] = Vec_PtrSize( p->vCis );
+ p->nObjs[AIG_OBJ_CO] = Vec_PtrSize( p->vCos );
}
Vec_PtrFree( vNodes );
- p->nTruePis = Aig_ManPiNum(p) - Aig_ManRegNum(p);
- p->nTruePos = Aig_ManPoNum(p) - Aig_ManRegNum(p);
+ p->nTruePis = Aig_ManCiNum(p) - Aig_ManRegNum(p);
+ p->nTruePos = Aig_ManCoNum(p) - Aig_ManRegNum(p);
Aig_ManSetPioNumbers( p );
// remove dangling nodes
return Aig_ManCleanup( p );
@@ -277,13 +277,13 @@ int Aig_ManSeqCleanupBasic( Aig_Man_t * p )
// mark the nodes reachable from these nodes
Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
Aig_ManSeqCleanup_rec( p, pObj, vNodes );
- assert( Vec_PtrSize(vNodes) <= Aig_ManPoNum(p) );
+ assert( Vec_PtrSize(vNodes) <= Aig_ManCoNum(p) );
// clean latch output pointers
Aig_ManForEachLiLoSeq( p, pObjLi, pObjLo, i )
pObjLo->pNext = NULL;
// if some latches are removed, update PIs/POs
- if ( Vec_PtrSize(vNodes) < Aig_ManPoNum(p) )
+ if ( Vec_PtrSize(vNodes) < Aig_ManCoNum(p) )
{
// add constant drivers to the dangling latches
Aig_ManForEachCo( p, pObj, i )
@@ -396,7 +396,7 @@ Vec_Ptr_t * Aig_ManReduceLachesOnce( Aig_Man_t * p )
Aig_Obj_t * pObj, * pObjLi, * pObjLo, * pFanin;
int * pMapping, i;
// start mapping by adding the true PIs
- vMap = Vec_PtrAlloc( Aig_ManPiNum(p) );
+ vMap = Vec_PtrAlloc( Aig_ManCiNum(p) );
Aig_ManForEachPiSeq( p, pObj, i )
Vec_PtrPush( vMap, pObj );
// create mapping of fanin nodes into the corresponding latch outputs
@@ -504,14 +504,14 @@ void Aig_ManComputeSccs( Aig_Man_t * p )
{
// skip true POs
iOut = Vec_IntPop( vSupp );
- iOut -= Aig_ManPoNum(p) - Aig_ManRegNum(p);
+ iOut -= Aig_ManCoNum(p) - Aig_ManRegNum(p);
if ( iOut < 0 )
continue;
// remove PIs
m = 0;
Vec_IntForEachEntry( vSupp, iIn, k )
{
- iIn -= Aig_ManPiNum(p) - Aig_ManRegNum(p);
+ iIn -= Aig_ManCiNum(p) - Aig_ManRegNum(p);
if ( iIn < 0 )
continue;
assert( iIn < Aig_ManRegNum(p) );
@@ -623,7 +623,7 @@ Aig_Man_t * Aig_ManSclPart( Aig_Man_t * pAig, int fLatchConst, int fLatchEqual,
nClasses = Aig_TransferMappedClasses( pAig, pTemp, pMapBack );
if ( fVerbose )
printf( "%3d : Reg = %4d. PI = %4d. (True = %4d. Regs = %4d.) And = %5d. It = %3d. Cl = %5d\n",
- i, Vec_IntSize(vPart), Aig_ManPiNum(pTemp)-Vec_IntSize(vPart), nCountPis, nCountRegs, Aig_ManNodeNum(pTemp), 0, nClasses );
+ i, Vec_IntSize(vPart), Aig_ManCiNum(pTemp)-Vec_IntSize(vPart), nCountPis, nCountRegs, Aig_ManNodeNum(pTemp), 0, nClasses );
Aig_ManStop( pNew );
}
Aig_ManStop( pTemp );
@@ -671,13 +671,13 @@ Aig_Man_t * Aig_ManScl( Aig_Man_t * pAig, int fLatchConst, int fLatchEqual, int
if ( fLatchEqual && pAig->nRegs )
pAig = Aig_ManReduceLaches( pAig, fVerbose );
// translate pairs into reprs
- nTruePis = Aig_ManPiNum(pAigInit)-Aig_ManRegNum(pAigInit);
+ nTruePis = Aig_ManCiNum(pAigInit)-Aig_ManRegNum(pAigInit);
Aig_ManReprStart( pAigInit, Aig_ManObjNumMax(pAigInit) );
Vec_IntForEachEntry( pAig->vFlopReprs, Entry1, i )
{
Entry2 = Vec_IntEntry( pAig->vFlopReprs, ++i );
- pFlop1 = Aig_ManPi( pAigInit, nTruePis + Entry1 );
- pFlop2 = (Entry2 == -1)? Aig_ManConst1(pAigInit) : Aig_ManPi( pAigInit, nTruePis + Entry2 );
+ pFlop1 = Aig_ManCi( pAigInit, nTruePis + Entry1 );
+ pFlop2 = (Entry2 == -1)? Aig_ManConst1(pAigInit) : Aig_ManCi( pAigInit, nTruePis + Entry2 );
assert( pFlop1 != pFlop2 );
if ( pFlop1->Id > pFlop2->Id )
pAigInit->pReprs[pFlop1->Id] = pFlop2;
diff --git a/src/aig/aig/aigShow.c b/src/aig/aig/aigShow.c
index 14a67806..b14032d3 100644
--- a/src/aig/aig/aigShow.c
+++ b/src/aig/aig/aigShow.c
@@ -256,7 +256,7 @@ void Aig_WriteDotAig( Aig_Man_t * pMan, char * pFileName, int fHaig, Vec_Ptr_t *
// generate edges
Aig_ManForEachObj( pMan, pNode, i )
{
- if ( !Aig_ObjIsNode(pNode) && !Aig_ObjIsPo(pNode) && !Aig_ObjIsBuf(pNode) )
+ if ( !Aig_ObjIsNode(pNode) && !Aig_ObjIsCo(pNode) && !Aig_ObjIsBuf(pNode) )
continue;
// generate the edge from this node to the next
fprintf( pFile, "Node%d", pNode->Id );
diff --git a/src/aig/aig/aigSplit.c b/src/aig/aig/aigSplit.c
index 3e4e8ed4..f187860f 100644
--- a/src/aig/aig/aigSplit.c
+++ b/src/aig/aig/aigSplit.c
@@ -194,7 +194,7 @@ DdManager * Aig_ManBuildPoBdd( Aig_Man_t * p, DdNode ** pbFunc )
int i;
assert( Saig_ManPoNum(p) == 1 );
Aig_ManCleanData( p );
- dd = Cudd_Init( Aig_ManPiNum(p), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
+ dd = Cudd_Init( Aig_ManCiNum(p), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
Cudd_AutodynEnable( dd, CUDD_REORDER_SYMM_SIFT );
pObj = Aig_ManConst1(p);
pObj->pData = Cudd_ReadOne(dd); Cudd_Ref( (DdNode *)pObj->pData );
@@ -202,7 +202,7 @@ DdManager * Aig_ManBuildPoBdd( Aig_Man_t * p, DdNode ** pbFunc )
{
pObj->pData = Cudd_bddIthVar(dd, i); Cudd_Ref( (DdNode *)pObj->pData );
}
- pObj = Aig_ManPo( p, 0 );
+ pObj = Aig_ManCo( p, 0 );
*pbFunc = Aig_ManBuildPoBdd_rec( p, Aig_ObjFanin0(pObj), dd ); Cudd_Ref( *pbFunc );
*pbFunc = Cudd_NotCond( *pbFunc, Aig_ObjFaninC0(pObj) );
Aig_ManForEachObj( p, pObj, i )
@@ -274,7 +274,7 @@ Aig_Man_t * Aig_ManSplit( Aig_Man_t * p, int nVars, int fVerbose )
printf( "The number of cofactoring variables should be less than 17.\n" );
return NULL;
}
- vSupp = Aig_Support( p, Aig_ObjFanin0(Aig_ManPo(p,0)) );
+ vSupp = Aig_Support( p, Aig_ObjFanin0(Aig_ManCo(p,0)) );
if ( Vec_PtrSize(vSupp) == 0 )
{
printf( "Property output function is a constant.\n" );
diff --git a/src/aig/aig/aigTsim.c b/src/aig/aig/aigTsim.c
index 99aa5c64..36dc28dd 100644
--- a/src/aig/aig/aigTsim.c
+++ b/src/aig/aig/aigTsim.c
@@ -458,7 +458,7 @@ Aig_TsiStatePrint( pTsi, pState );
}
// start mapping by adding the true PIs
- vMap = Vec_PtrAlloc( Aig_ManPiNum(p) );
+ vMap = Vec_PtrAlloc( Aig_ManCiNum(p) );
Aig_ManForEachPiSeq( p, pObj, i )
Vec_PtrPush( vMap, pObj );
// find constant registers
diff --git a/src/aig/aig/aigUtil.c b/src/aig/aig/aigUtil.c
index 16065b4e..c247208f 100644
--- a/src/aig/aig/aigUtil.c
+++ b/src/aig/aig/aigUtil.c
@@ -85,7 +85,7 @@ char * Aig_TimeStamp()
***********************************************************************/
int Aig_ManHasNoGaps( Aig_Man_t * p )
{
- return (int)(Aig_ManObjNum(p) == Aig_ManPiNum(p) + Aig_ManPoNum(p) + Aig_ManNodeNum(p) + 1);
+ return (int)(Aig_ManObjNum(p) == Aig_ManCiNum(p) + Aig_ManCoNum(p) + Aig_ManNodeNum(p) + 1);
}
/**Function*************************************************************
@@ -243,7 +243,7 @@ void Aig_ManCleanNext( Aig_Man_t * p )
void Aig_ObjCleanData_rec( Aig_Obj_t * pObj )
{
assert( !Aig_IsComplement(pObj) );
- assert( !Aig_ObjIsPo(pObj) );
+ assert( !Aig_ObjIsCo(pObj) );
if ( Aig_ObjIsAnd(pObj) )
{
Aig_ObjCleanData_rec( Aig_ObjFanin0(pObj) );
@@ -266,7 +266,7 @@ void Aig_ObjCleanData_rec( Aig_Obj_t * pObj )
***********************************************************************/
void Aig_ObjCollectMulti_rec( Aig_Obj_t * pRoot, Aig_Obj_t * pObj, Vec_Ptr_t * vSuper )
{
- if ( pRoot != pObj && (Aig_IsComplement(pObj) || Aig_ObjIsPi(pObj) || Aig_ObjType(pRoot) != Aig_ObjType(pObj)) )
+ if ( pRoot != pObj && (Aig_IsComplement(pObj) || Aig_ObjIsCi(pObj) || Aig_ObjType(pRoot) != Aig_ObjType(pObj)) )
{
Vec_PtrPushUnique(vSuper, pObj);
return;
@@ -531,7 +531,7 @@ void Aig_ObjPrintEqn( FILE * pFile, Aig_Obj_t * pObj, Vec_Vec_t * vLevels, int L
return;
}
// PI case
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
{
fprintf( pFile, "%s%s", fCompl? "!" : "", (char*)pObj->pData );
return;
@@ -578,7 +578,7 @@ void Aig_ObjPrintVerilog( FILE * pFile, Aig_Obj_t * pObj, Vec_Vec_t * vLevels, i
return;
}
// PI case
- if ( Aig_ObjIsPi(pObj) )
+ if ( Aig_ObjIsCi(pObj) )
{
fprintf( pFile, "%s%s", fCompl? "~" : "", (char*)pObj->pData );
return;
@@ -656,9 +656,9 @@ void Aig_ObjPrintVerbose( Aig_Obj_t * pObj, int fHaig )
printf( "Node %p : ", pObj );
if ( Aig_ObjIsConst1(pObj) )
printf( "constant 1" );
- else if ( Aig_ObjIsPi(pObj) )
+ else if ( Aig_ObjIsCi(pObj) )
printf( "PI" );
- else if ( Aig_ObjIsPo(pObj) )
+ else if ( Aig_ObjIsCo(pObj) )
{
printf( "PO" );
printf( "%p%s",
@@ -736,7 +736,7 @@ void Aig_ManDumpBlif( Aig_Man_t * p, char * pFileName, Vec_Ptr_t * vPiNames, Vec
Vec_Ptr_t * vNodes;
Aig_Obj_t * pObj, * pObjLi, * pObjLo, * pConst1 = NULL;
int i, nDigits, Counter = 0;
- if ( Aig_ManPoNum(p) == 0 )
+ if ( Aig_ManCoNum(p) == 0 )
{
printf( "Aig_ManDumpBlif(): AIG manager does not have POs.\n" );
return;
@@ -785,11 +785,11 @@ void Aig_ManDumpBlif( Aig_Man_t * p, char * pFileName, Vec_Ptr_t * vPiNames, Vec
{
fprintf( pFile, ".latch" );
if ( vPoNames )
- fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPoNames, Aig_ManPoNum(p)-Aig_ManRegNum(p)+i) );
+ fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPoNames, Aig_ManCoNum(p)-Aig_ManRegNum(p)+i) );
else
fprintf( pFile, " n%0*d", nDigits, pObjLi->iData );
if ( vPiNames )
- fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPiNames, Aig_ManPiNum(p)-Aig_ManRegNum(p)+i) );
+ fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPiNames, Aig_ManCiNum(p)-Aig_ManRegNum(p)+i) );
else
fprintf( pFile, " n%0*d", nDigits, pObjLo->iData );
fprintf( pFile, " 0\n" );
@@ -803,11 +803,11 @@ void Aig_ManDumpBlif( Aig_Man_t * p, char * pFileName, Vec_Ptr_t * vPiNames, Vec
Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
{
fprintf( pFile, ".names" );
- if ( vPiNames && Aig_ObjIsPi(Aig_ObjFanin0(pObj)) )
+ if ( vPiNames && Aig_ObjIsCi(Aig_ObjFanin0(pObj)) )
fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPiNames, Aig_ObjPioNum(Aig_ObjFanin0(pObj))) );
else
fprintf( pFile, " n%0*d", nDigits, Aig_ObjFanin0(pObj)->iData );
- if ( vPiNames && Aig_ObjIsPi(Aig_ObjFanin1(pObj)) )
+ if ( vPiNames && Aig_ObjIsCi(Aig_ObjFanin1(pObj)) )
fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPiNames, Aig_ObjPioNum(Aig_ObjFanin1(pObj))) );
else
fprintf( pFile, " n%0*d", nDigits, Aig_ObjFanin1(pObj)->iData );
@@ -818,7 +818,7 @@ void Aig_ManDumpBlif( Aig_Man_t * p, char * pFileName, Vec_Ptr_t * vPiNames, Vec
Aig_ManForEachCo( p, pObj, i )
{
fprintf( pFile, ".names" );
- if ( vPiNames && Aig_ObjIsPi(Aig_ObjFanin0(pObj)) )
+ if ( vPiNames && Aig_ObjIsCi(Aig_ObjFanin0(pObj)) )
fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPiNames, Aig_ObjPioNum(Aig_ObjFanin0(pObj))) );
else
fprintf( pFile, " n%0*d", nDigits, Aig_ObjFanin0(pObj)->iData );
@@ -851,7 +851,7 @@ void Aig_ManDumpVerilog( Aig_Man_t * p, char * pFileName )
Vec_Ptr_t * vNodes;
Aig_Obj_t * pObj, * pObjLi, * pObjLo, * pConst1 = NULL;
int i, nDigits, Counter = 0;
- if ( Aig_ManPoNum(p) == 0 )
+ if ( Aig_ManCoNum(p) == 0 )
{
printf( "Aig_ManDumpBlif(): AIG manager does not have POs.\n" );
return;
@@ -1029,7 +1029,7 @@ void Aig_ManPrintControlFanouts( Aig_Man_t * p )
Aig_Obj_t * pObj, * pFanin0, * pFanin1, * pCtrl;
int i;
- pCtrl = Aig_ManPi( p, Aig_ManPiNum(p) - 1 );
+ pCtrl = Aig_ManCi( p, Aig_ManCiNum(p) - 1 );
printf( "Control signal:\n" );
Aig_ObjPrint( p, pCtrl ); printf( "\n\n" );
@@ -1041,13 +1041,13 @@ void Aig_ManPrintControlFanouts( Aig_Man_t * p )
assert( pObj != pCtrl );
pFanin0 = Aig_ObjFanin0(pObj);
pFanin1 = Aig_ObjFanin1(pObj);
- if ( pFanin0 == pCtrl && Aig_ObjIsPi(pFanin1) )
+ if ( pFanin0 == pCtrl && Aig_ObjIsCi(pFanin1) )
{
Aig_ObjPrint( p, pObj ); printf( "\n" );
Aig_ObjPrint( p, pFanin1 ); printf( "\n" );
printf( "\n" );
}
- if ( pFanin1 == pCtrl && Aig_ObjIsPi(pFanin0) )
+ if ( pFanin1 == pCtrl && Aig_ObjIsCi(pFanin0) )
{
Aig_ObjPrint( p, pObj ); printf( "\n" );
Aig_ObjPrint( p, pFanin0 ); printf( "\n" );
@@ -1355,7 +1355,7 @@ void Aig_ManCounterExampleValueStart( Aig_Man_t * pAig, Abc_Cex_t * pCex )
}
assert( iBit == pCex->nBits );
// check that the counter-example is correct, that is, the corresponding output is asserted
- assert( Abc_InfoHasBit( (unsigned *)pAig->pData2, nObjs * pCex->iFrame + Aig_ObjId(Aig_ManPo(pAig, pCex->iPo)) ) );
+ assert( Abc_InfoHasBit( (unsigned *)pAig->pData2, nObjs * pCex->iFrame + Aig_ObjId(Aig_ManCo(pAig, pCex->iPo)) ) );
}
/**Function*************************************************************
diff --git a/src/aig/aig/aigWin.c b/src/aig/aig/aigWin.c
index 5568c9ec..cc179267 100644
--- a/src/aig/aig/aigWin.c
+++ b/src/aig/aig/aigWin.c
@@ -49,7 +49,7 @@ static inline int Aig_NodeGetLeafCostOne( Aig_Obj_t * pNode, int nFanoutLimit )
// make sure the node is in the construction zone
assert( pNode->fMarkA );
// cannot expand over the PI node
- if ( Aig_ObjIsPi(pNode) )
+ if ( Aig_ObjIsCi(pNode) )
return 999;
// get the cost of the cone
Cost = (!Aig_ObjFanin0(pNode)->fMarkA) + (!Aig_ObjFanin1(pNode)->fMarkA);
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-28 16:20:30 +0000