Skip to content

A
abc
Commit 477ecc17 by Alan Mishchenko
Options

Renaming Cba into Bac.

parent ddda9320
Showing with 787 additions and 2084 deletions
abclib.dsp
......@@ -782,120 +782,172 @@ SOURCE=.\src\base\wlc\wlcStdin.c
SOURCE=.\src\base\wlc\wlcWriteVer.c
# End Source File
# End Group
# Begin Group "cba"
# Begin Group "pla"
# PROP Default_Filter ""
# Begin Source File
SOURCE=.\src\base\cba\cba.h
SOURCE=.\src\base\pla\pla.h
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaBlast.c
SOURCE=.\src\base\pla\plaCom.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaCba.c
SOURCE=.\src\base\pla\plaFxch.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaCom.c
SOURCE=.\src\base\pla\plaHash.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaLib.c
SOURCE=.\src\base\pla\plaMan.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaNtk.c
SOURCE=.\src\base\pla\plaMerge.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaOper.c
SOURCE=.\src\base\pla\plaRead.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaPrs.h
SOURCE=.\src\base\pla\plaSimple.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaPrsBuild.c
SOURCE=.\src\base\pla\plaWrite.c
# End Source File
# End Group
# Begin Group "bac"
# PROP Default_Filter ""
# Begin Source File
SOURCE=.\src\base\cba\cbaPrsTrans.c
SOURCE=.\src\base\bac\bac.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaPtr.c
SOURCE=.\src\base\bac\bac.h
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaPtrAbc.c
SOURCE=.\src\base\bac\bacBac.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaReadBlif.c
SOURCE=.\src\base\bac\bacBlast.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaReadSmt.c
SOURCE=.\src\base\bac\bacCom.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaReadVer.c
SOURCE=.\src\base\bac\bacLib.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaWriteBlif.c
SOURCE=.\src\base\bac\bacNtk.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaWriteSmt.c
SOURCE=.\src\base\bac\bacOper.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaWriteVer.c
SOURCE=.\src\base\bac\bacPrs.h
# End Source File
# Begin Source File
SOURCE=.\src\base\bac\bacPrsBuild.c
# End Source File
# Begin Source File
SOURCE=.\src\base\bac\bacPrsTrans.c
# End Source File
# Begin Source File
SOURCE=.\src\base\bac\bacPrtAbc.c
# End Source File
# Begin Source File
SOURCE=.\src\base\bac\bacPtr.c
# End Source File
# Begin Source File
SOURCE=.\src\base\bac\bacReadBlif.c
# End Source File
# Begin Source File
SOURCE=.\src\base\bac\bacReadSmt.c
# End Source File
# Begin Source File
SOURCE=.\src\base\bac\bacReadVec.c
# End Source File
# Begin Source File
SOURCE=.\src\base\bac\bacWriteBlif.c
# End Source File
# Begin Source File
SOURCE=.\src\base\bac\bacWriteSmt.c
# End Source File
# Begin Source File
SOURCE=.\src\base\bac\bacWriteVer.c
# End Source File
# End Group
# Begin Group "pla"
# Begin Group "cba"
# PROP Default_Filter ""
# Begin Source File
SOURCE=.\src\base\pla\pla.h
SOURCE=.\src\base\cba\cba.c
# End Source File
# Begin Source File
SOURCE=.\src\base\pla\plaCom.c
SOURCE=.\src\base\cba\cba.h
# End Source File
# Begin Source File
SOURCE=.\src\base\pla\plaFxch.c
SOURCE=.\src\base\cba\cbaBlast.c
# End Source File
# Begin Source File
SOURCE=.\src\base\pla\plaHash.c
SOURCE=.\src\base\cba\cbaCba.c
# End Source File
# Begin Source File
SOURCE=.\src\base\pla\plaMan.c
SOURCE=.\src\base\cba\cbaCom.c
# End Source File
# Begin Source File
SOURCE=.\src\base\pla\plaMerge.c
SOURCE=.\src\base\cba\cbaNtk.c
# End Source File
# Begin Source File
SOURCE=.\src\base\pla\plaRead.c
SOURCE=.\src\base\cba\cbaPrs.h
# End Source File
# Begin Source File
SOURCE=.\src\base\pla\plaSimple.c
SOURCE=.\src\base\cba\cbaReadBlif.c
# End Source File
# Begin Source File
SOURCE=.\src\base\pla\plaWrite.c
SOURCE=.\src\base\cba\cbaReadVer.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaWriteBlif.c
# End Source File
# Begin Source File
SOURCE=.\src\base\cba\cbaWriteVer.c
# End Source File
# End Group
# End Group
......
src/base/cba/cba.c
......@@ -12,7 +12,7 @@
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - November 29, 2014.]
Date [Ver. 1.0. Started - July 21, 2015.]
Revision [$Id: cba.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
......
src/base/cba/cba.h
......@@ -12,7 +12,7 @@
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - November 29, 2014.]
Date [Ver. 1.0. Started - July 21, 2015.]
Revision [$Id: cba.h,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
......@@ -44,14 +44,16 @@ typedef enum {
CBA_OBJ_NONE = 0, // 0: unused
CBA_OBJ_PI, // 1: input
CBA_OBJ_PO, // 2: output
CBA_OBJ_BI, // 3: box input
CBA_OBJ_BO, // 4: box output
CBA_OBJ_BOX, // 5: box
CBA_OBJ_BOX, // 3: box
CBA_BOX_SLICE,
CBA_BOX_CONCAT,
CBA_BOX_CF,
CBA_BOX_CT,
CBA_BOX_CX,
CBA_BOX_CZ,
CBA_BOX_BUF,
CBA_BOX_INV,
CBA_BOX_AND,
......@@ -93,7 +95,7 @@ typedef enum {
CBA_BOX_DIV,
CBA_BOX_MOD,
CBA_BOX_REM,
CBA_BOX_POW,
CBA_OBJ_POW,
CBA_BOX_MIN,
CBA_BOX_ABS,
......@@ -125,18 +127,10 @@ typedef enum {
CBA_BOX_DFF,
CBA_BOX_DFFRS,
CBA_BOX_UNKNOWN // 67
CBA_BOX_LAST // 67
} Cba_ObjType_t;
// name types
typedef enum {
CBA_NAME_BIN = 0, // 0: binary variable
CBA_NAME_WORD, // 1: first bit of word-level variable
CBA_NAME_INFO, // 2: first bit of special variable
CBA_NAME_INDEX, // 3: index of word-level variable
} Cba_NameType_t;
typedef struct Cba_Ntk_t_ Cba_Ntk_t;
typedef struct Cba_Man_t_ Cba_Man_t;
......@@ -145,26 +139,40 @@ typedef struct Cba_Man_t_ Cba_Man_t;
struct Cba_Ntk_t_
{
Cba_Man_t * pDesign; // design
int Id; // network ID
int NameId; // name ID
int iCopy; // copy module
int iBoxNtk; // instance network ID
int iBoxObj; // instance object ID
int Count; // object counter
int Mark; // visit mark
// interface
Vec_Int_t vInputs; // inputs
Vec_Int_t vOutputs; // outputs
Vec_Int_t vInfo; // input/output/wire info
// object attributes
Vec_Str_t vType; // types
Vec_Int_t vFanin; // fanin
Vec_Int_t vIndex; // index
Vec_Int_t vName; // original NameId or InstId
Vec_Int_t vFanout; // fanout
Vec_Int_t vCopy; // copy
Vec_Int_t vOrder; // order
// stucture
Vec_Str_t vObjType; // type
Vec_Int_t vObjFin0; // fanins
Vec_Int_t vObjFon0; // outputs
Vec_Int_t vFinFon; // fons
Vec_Int_t vFonObj; // object
// optional
Vec_Int_t vObjCopy; // copy
Vec_Int_t vObjFunc; // function
Vec_Int_t vObjName; // name
Vec_Int_t vObjAttr; // attribute offset
Vec_Int_t vAttrSto; // attribute storage
Vec_Int_t vFonCopy; // copy
Vec_Int_t vFonName; // name
Vec_Int_t vFonRange;// range
Vec_Int_t vFonLeft; // left
Vec_Int_t vFonRight;// right
Vec_Int_t vFonPrev; // fanout: prev fon
Vec_Int_t vFonNext; // fanout: next fon
Vec_Int_t vFinFon0; // fanout: first fon
Vec_Int_t vFinObj; // object
Vec_Int_t vNtkObjs; // instances
// other
Vec_Int_t vArray;
Vec_Int_t vArray2;
Vec_Ptr_t * vOther; // various data
Vec_Int_t vArray0;
Vec_Int_t vArray1;
};
// design
......@@ -177,155 +185,166 @@ struct Cba_Man_t_
Abc_Nam_t * pMods; // module name manager
// internal data
int iRoot; // root network
int nNtks; // number of current networks
Cba_Ntk_t * pNtks; // networks
Vec_Ptr_t vNtks; // networks
// user data
Vec_Str_t * vOut;
Vec_Str_t * vOut2;
Vec_Int_t vBuf2RootNtk;
Vec_Int_t vBuf2RootObj;
Vec_Int_t vBuf2LeafNtk;
Vec_Int_t vBuf2LeafObj;
void * pMioLib;
void ** ppGraphs;
int ElemGates[4];
char * pPrimNames[CBA_BOX_UNKNOWN];
char * pPrimSymbs[CBA_BOX_UNKNOWN];
};
////////////////////////////////////////////////////////////////////////
/// MACRO DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
static inline char * Cba_ManName( Cba_Man_t * p ) { return p->pName; }
static inline char * Cba_ManSpec( Cba_Man_t * p ) { return p->pSpec; }
static inline int Cba_ManNtkNum( Cba_Man_t * p ) { return p->nNtks; }
static inline int Cba_ManPrimNum( Cba_Man_t * p ) { return Abc_NamObjNumMax(p->pMods) - Cba_ManNtkNum(p); }
static inline int Cba_ManNtkNum( Cba_Man_t * p ) { return Vec_PtrSize(&p->vNtks)-1; }
static inline int Cba_ManNtkIsOk( Cba_Man_t * p, int i ) { return i > 0 && i <= Cba_ManNtkNum(p); }
static inline Cba_Ntk_t * Cba_ManNtk( Cba_Man_t * p, int i ) { return Cba_ManNtkIsOk(p, i) ? p->pNtks + i : NULL; }
static inline Cba_Ntk_t * Cba_ManNtk( Cba_Man_t * p, int i ) { return Cba_ManNtkIsOk(p, i) ? (Cba_Ntk_t *)Vec_PtrEntry(&p->vNtks, i) : NULL; }
static inline int Cba_ManNtkFindId( Cba_Man_t * p, char * pName ) { return Abc_NamStrFind(p->pMods, pName); }
static inline Cba_Ntk_t * Cba_ManNtkFind( Cba_Man_t * p, char * pName ) { return Cba_ManNtk( p, Cba_ManNtkFindId(p, pName) ); }
static inline Cba_Ntk_t * Cba_ManRoot( Cba_Man_t * p ) { return Cba_ManNtk(p, p->iRoot); }
static inline char * Cba_ManStr( Cba_Man_t * p, int i ) { return Abc_NamStr(p->pStrs, i); }
static inline int Cba_ManStrId( Cba_Man_t * p, char * pStr ) { return Abc_NamStrFind(p->pStrs, pStr); }
static inline char * Cba_ManPrimName( Cba_Man_t * p, Cba_ObjType_t Type ) { return p->pPrimNames[Type]; }
static inline char * Cba_ManPrimSymb( Cba_Man_t * p, Cba_ObjType_t Type ) { return p->pPrimSymbs[Type]; }
static inline int Cba_ManNewStrId( Cba_Man_t * p, char * pPref, int n, char * pSuff ) { char pStr[100]; sprintf(pStr, "%s%d%s", pPref?pPref:"", n, pSuff?pSuff:""); return Abc_NamStrFindOrAdd(p->pStrs, pStr, NULL); }
static inline int Cba_ManNameIdMax( Cba_Man_t * p ) { return Abc_NamObjNumMax(p->pStrs) + 1; }
static inline int Cba_NtkId( Cba_Ntk_t * p ) { int i = p - p->pDesign->pNtks; assert(Cba_ManNtkIsOk(p->pDesign, i)); return i; }
static inline Cba_Man_t * Cba_NtkMan( Cba_Ntk_t * p ) { return p->pDesign; }
static inline int Cba_NtkNameId( Cba_Ntk_t * p ) { return p->NameId; }
static inline char * Cba_NtkName( Cba_Ntk_t * p ) { return Cba_ManStr(p->pDesign, Cba_NtkNameId(p)); }
static inline Cba_Ntk_t * Cba_NtkNtk( Cba_Ntk_t * p, int i ) { return Cba_ManNtk(p->pDesign, i); }
static inline int Cba_NtkId( Cba_Ntk_t * p ) { return p->Id; }
static inline int Cba_NtkPi( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInputs, i); }
static inline int Cba_NtkPo( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vOutputs, i); }
static inline char * Cba_NtkStr( Cba_Ntk_t * p, int i ) { return Cba_ManStr(p->pDesign, i); }
static inline char * Cba_NtkName( Cba_Ntk_t * p ) { return Cba_NtkStr(p, p->NameId); }
static inline int Cba_NtkCopy( Cba_Ntk_t * p ) { return p->iCopy; }
static inline Cba_Ntk_t * Cba_NtkCopyNtk(Cba_Man_t * pNew, Cba_Ntk_t * p) { return Cba_ManNtk(pNew, Cba_NtkCopy(p)); }
static inline void Cba_NtkSetCopy( Cba_Ntk_t * p, int i ) { assert(p->iCopy == -1); p->iCopy = i; }
static inline void Cba_NtkSetCopy( Cba_Ntk_t * p, int i ) { assert(p->iCopy == 0); p->iCopy = i; }
static inline int Cba_NtkObjNum( Cba_Ntk_t * p ) { return Vec_StrSize(&p->vType); }
static inline int Cba_NtkObjNumAlloc( Cba_Ntk_t * p ) { return Vec_StrCap(&p->vType); }
static inline int Cba_NtkPiNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vInputs); }
static inline int Cba_NtkPoNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vOutputs); }
static inline int Cba_NtkPioNum( Cba_Ntk_t * p ) { return Cba_NtkPiNum(p) + Cba_NtkPoNum(p); }
static inline int Cba_NtkPiNumAlloc( Cba_Ntk_t * p ) { return Vec_IntCap(&p->vInputs); }
static inline int Cba_NtkPoNumAlloc( Cba_Ntk_t * p ) { return Vec_IntCap(&p->vOutputs); }
static inline int Cba_NtkBiNum( Cba_Ntk_t * p ) { return Vec_StrCountEntryLit(&p->vType, (char)CBA_OBJ_BI); }
static inline int Cba_NtkBoNum( Cba_Ntk_t * p ) { return Vec_StrCountEntryLit(&p->vType, (char)CBA_OBJ_BO); }
static inline int Cba_NtkCiNum( Cba_Ntk_t * p ) { return Cba_NtkPiNum(p) + Cba_NtkBoNum(p); }
static inline int Cba_NtkCoNum( Cba_Ntk_t * p ) { return Cba_NtkPoNum(p) + Cba_NtkBiNum(p); }
static inline int Cba_NtkBoxNum( Cba_Ntk_t * p ) { return Cba_NtkObjNum(p) - Vec_StrCountSmallerLit(&p->vType, (char)CBA_OBJ_BOX); }
static inline int Cba_NtkPrimNum( Cba_Ntk_t * p ) { return Vec_StrCountLargerLit(&p->vType, (char)CBA_OBJ_BOX); }
static inline int Cba_NtkUserNum( Cba_Ntk_t * p ) { return Vec_StrCountEntryLit(&p->vType, (char)CBA_OBJ_BOX); }
static inline int Cba_NtkObjNum( Cba_Ntk_t * p ) { return Vec_StrSize(&p->vObjType)-1; }
static inline int Cba_NtkObjNumAlloc( Cba_Ntk_t * p ) { return Vec_StrCap(&p->vObjType)-1; }
static inline int Cba_NtkFinNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFinFon)-1; }
static inline int Cba_NtkFinNumAlloc( Cba_Ntk_t * p ) { return Vec_IntCap(&p->vFinFon)-1; }
static inline int Cba_NtkFonNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFonObj)-1; }
static inline int Cba_NtkFonNumAlloc( Cba_Ntk_t * p ) { return Vec_IntCap(&p->vFonObj)-1; }
static inline int Cba_NtkTypeNum( Cba_Ntk_t * p, int Type ) { return Vec_StrCountEntry(&p->vObjType, (char)Type); }
static inline int Cba_NtkBoxNum( Cba_Ntk_t * p ) { return Cba_NtkObjNum(p) - Cba_NtkPioNum(p); }
static inline int Cba_NtkBoxUserNum( Cba_Ntk_t * p ) { return Cba_NtkTypeNum(p, CBA_OBJ_BOX); }
static inline int Cba_NtkBoxPrimNum( Cba_Ntk_t * p ) { return Vec_StrCountLarger(&p->vObjType, (char)CBA_OBJ_BOX); }
static inline void Cba_NtkStartObjCopies( Cba_Ntk_t * p ) { Vec_IntFill(&p->vObjCopy, Vec_StrCap(&p->vObjType), -1); }
static inline void Cba_NtkStartObjFuncs( Cba_Ntk_t * p ) { Vec_IntFill(&p->vObjFunc, Vec_StrCap(&p->vObjType), 0); }
static inline void Cba_NtkStartObjNames( Cba_Ntk_t * p ) { Vec_IntFill(&p->vObjName, Vec_StrCap(&p->vObjType), 0); }
static inline void Cba_NtkStartObjAttrs( Cba_Ntk_t * p ) { Vec_IntFill(&p->vObjAttr, Vec_StrCap(&p->vObjType), 0); }
static inline void Cba_NtkStartFonCopies( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFonCopy, Vec_IntCap(&p->vFonObj), 0); }
static inline void Cba_NtkStartFonNames( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFonName, Vec_IntCap(&p->vFonObj), 0); }
static inline void Cba_NtkStartFonRanges( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFonRange,Vec_IntCap(&p->vFonObj), 0); }
static inline void Cba_NtkStartFonLefts( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFonLeft, Vec_IntCap(&p->vFonObj), 0); }
static inline void Cba_NtkStartFonRights( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFonRight,Vec_IntCap(&p->vFonObj), 0); }
static inline void Cba_NtkStartFonPrevs( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFonPrev, Vec_IntCap(&p->vFonObj), 0); }
static inline void Cba_NtkStartFonNexts( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFonNext, Vec_IntCap(&p->vFonObj), 0); }
static inline void Cba_NtkStartFinFon0( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFinFon0, Vec_IntCap(&p->vFinFon), 0); }
static inline void Cba_NtkStartFinObjs( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFinObj, Vec_IntCap(&p->vFinFon), 0); }
static inline void Cba_NtkFreeObjCopies( Cba_Ntk_t * p ) { Vec_IntErase(&p->vObjCopy); }
static inline void Cba_NtkFreeObjFuncs( Cba_Ntk_t * p ) { Vec_IntErase(&p->vObjFunc); }
static inline void Cba_NtkFreeObjNames( Cba_Ntk_t * p ) { Vec_IntErase(&p->vObjName); }
static inline void Cba_NtkFreeObjAttrs( Cba_Ntk_t * p ) { Vec_IntErase(&p->vObjAttr); }
static inline void Cba_NtkFreeFonCopies( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFonCopy); }
static inline void Cba_NtkFreeFonNames( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFonName); }
static inline void Cba_NtkFreeFonRanges( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFonRange); }
static inline void Cba_NtkFreeFonLefts( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFonLeft); }
static inline void Cba_NtkFreeFonRights( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFonRight); }
static inline void Cba_NtkFreeFonPrevs( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFonPrev); }
static inline void Cba_NtkFreeFonNexts( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFonNext); }
static inline void Cba_NtkFreeFinFon0( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFinFon0); }
static inline void Cba_NtkFreeFinObjs( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFinObj); }
static inline int Cba_NtkHasObjCopies( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vObjCopy) > 0; }
static inline int Cba_NtkHasObjFuncs( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vObjFunc) > 0; }
static inline int Cba_NtkHasObjNames( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vObjName) > 0; }
static inline int Cba_NtkHasObjAttrs( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vObjAttr) > 0; }
static inline int Cba_NtkHasFonCopies( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFonCopy) > 0; }
static inline int Cba_NtkHasFonNames( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFonName) > 0; }
static inline int Cba_NtkHasFonRanges( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFonRange)> 0; }
static inline int Cba_NtkHasFonLefts( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFonLeft) > 0; }
static inline int Cba_NtkHasFonRights( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFonRight)> 0; }
static inline int Cba_NtkHasFonPrevs( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFonPrev) > 0; }
static inline int Cba_NtkHasFonNexts( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFonNext) > 0; }
static inline int Cba_NtkHasFinFon0( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFinFon0) > 0; }
static inline int Cba_NtkHasFinObjs( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFinObj) > 0; }
static inline void Cba_NtkCleanObjCopies( Cba_Ntk_t * p ) { Vec_IntFill(&p->vObjCopy, Vec_StrSize(&p->vObjType), -1); }
static inline void Cba_NtkCleanFonCopies( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFonCopy, Vec_IntSize(&p->vFonObj), -1); }
static inline void Cba_NtkCleanFonNames( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFonName, Vec_IntSize(&p->vFonObj), 0); }
static inline Cba_ObjType_t Cba_ObjType( Cba_Ntk_t * p, int i ) { assert(i>0); return (Cba_ObjType_t)(int)(unsigned char)Vec_StrEntry(&p->vObjType, i); }
static inline void Cba_ObjCleanType( Cba_Ntk_t * p, int i ) { assert(i>0); Vec_StrWriteEntry( &p->vObjType, i, (char)CBA_OBJ_NONE ); }
static inline int Cba_TypeIsBox( Cba_ObjType_t Type ) { return Type >= CBA_OBJ_BOX && Type < CBA_BOX_LAST; }
static inline int Cba_NtkPi( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInputs, i); }
static inline int Cba_NtkPo( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vOutputs, i); }
static inline char * Cba_NtkStr( Cba_Ntk_t * p, int i ) { return Cba_ManStr(p->pDesign, i); }
static inline Cba_Ntk_t * Cba_NtkHostNtk( Cba_Ntk_t * p ) { return p->iBoxNtk > 0 ? Cba_ManNtk(p->pDesign, p->iBoxNtk) : NULL; }
static inline int Cba_NtkHostObj( Cba_Ntk_t * p ) { return p->iBoxObj; }
static inline void Cba_NtkSetHost( Cba_Ntk_t * p, int n, int i ) { assert(p->iBoxNtk == -1); p->iBoxNtk = n; p->iBoxObj = i; }
static inline int Cba_InfoRange( int Beg, int End ) { return End > Beg ? End - Beg + 1 : Beg - End + 1; }
static inline int Cba_NtkInfoNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vInfo)/3; }
static inline int Cba_NtkInfoNumAlloc( Cba_Ntk_t * p ) { return Vec_IntCap(&p->vInfo)/3; }
static inline int Cba_NtkInfoType( Cba_Ntk_t * p, int i ) { return Abc_Lit2Att2(Vec_IntEntry(&p->vInfo, 3*i)); }
static inline int Cba_NtkInfoName( Cba_Ntk_t * p, int i ) { return Abc_Lit2Var2(Vec_IntEntry(&p->vInfo, 3*i)); }
static inline int Cba_NtkInfoBeg( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInfo, 3*i+1); }
static inline int Cba_NtkInfoEnd( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInfo, 3*i+2); }
static inline int Cba_NtkInfoRange( Cba_Ntk_t * p, int i ) { int* a = Vec_IntEntryP(&p->vInfo, 3*i); return a[1]>=0 ? Cba_InfoRange( a[1], a[2] ) : 1; }
static inline int Cba_NtkInfoIndex( Cba_Ntk_t * p, int i, int j ) { int* a = Vec_IntEntryP(&p->vInfo, 3*i); assert(a[1]>=0); return a[1]<a[2] ? a[1]+j : a[1]-j;}
static inline void Cba_NtkAddInfo( Cba_Ntk_t * p,int i,int b,int e){ Vec_IntPush(&p->vInfo, i); Vec_IntPushTwo(&p->vInfo, b, e); }
static inline void Cba_NtkSetInfoName( Cba_Ntk_t * p, int i, int n){ Vec_IntWriteEntry( &p->vInfo, 3*i, n ); }
static inline void Cba_NtkStartNames( Cba_Ntk_t * p ) { assert(Cba_NtkObjNumAlloc(p)); Vec_IntFill(&p->vName, Cba_NtkObjNumAlloc(p), 0); }
static inline void Cba_NtkStartFanouts( Cba_Ntk_t * p ) { assert(Cba_NtkObjNumAlloc(p)); Vec_IntFill(&p->vFanout, Cba_NtkObjNumAlloc(p), 0); }
static inline void Cba_NtkStartCopies( Cba_Ntk_t * p ) { assert(Cba_NtkObjNumAlloc(p)); Vec_IntFill(&p->vCopy, Cba_NtkObjNumAlloc(p), -1); }
static inline void Cba_NtkFreeNames( Cba_Ntk_t * p ) { Vec_IntErase(&p->vName); }
static inline void Cba_NtkFreeFanouts( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFanout); }
static inline void Cba_NtkFreeCopies( Cba_Ntk_t * p ) { Vec_IntErase(&p->vCopy); }
static inline int Cba_NtkHasNames( Cba_Ntk_t * p ) { return p->vName.pArray != NULL; }
static inline int Cba_NtkHasFanouts( Cba_Ntk_t * p ) { return p->vFanout.pArray != NULL; }
static inline int Cba_NtkHasCopies( Cba_Ntk_t * p ) { return p->vCopy.pArray != NULL; }
static inline int Cba_TypeIsBox( Cba_ObjType_t Type ) { return Type >= CBA_OBJ_BOX && Type < CBA_BOX_UNKNOWN; }
static inline Cba_NameType_t Cba_NameType( int n ) { assert( n ); return (Cba_NameType_t)Abc_Lit2Att2( n ); }
static inline int Cba_CharIsDigit( char c ) { return c >= '0' && c <= '9'; }
static inline Cba_ObjType_t Cba_ObjType( Cba_Ntk_t * p, int i ) { return (Cba_ObjType_t)Abc_Lit2Var((int)(unsigned char)Vec_StrEntry(&p->vType, i)); }
static inline int Cba_ObjIsPi( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_PI; }
static inline int Cba_ObjIsPo( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_PO; }
static inline int Cba_ObjIsPio( Cba_Ntk_t * p, int i ) { return Cba_ObjIsPi(p, i) || Cba_ObjIsPo(p, i); }
static inline int Cba_ObjIsBi( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_BI; }
static inline int Cba_ObjIsBo( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_BO; }
static inline int Cba_ObjIsBio( Cba_Ntk_t * p, int i ) { return Cba_ObjIsBi(p, i) || Cba_ObjIsBo(p, i); }
static inline int Cba_ObjIsBox( Cba_Ntk_t * p, int i ) { return Cba_TypeIsBox(Cba_ObjType(p, i)); }
static inline int Cba_ObjIsBoxUser( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_BOX; }
static inline int Cba_ObjIsBoxPrim( Cba_Ntk_t * p, int i ) { return Cba_ObjIsBox(p, i) && !Cba_ObjIsBoxUser(p, i); }
static inline int Cba_ObjIsBoxPrim( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) > CBA_OBJ_BOX && Cba_ObjType(p, i) < CBA_BOX_LAST; }
static inline int Cba_ObjIsGate( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_BOX_GATE; }
static inline int Cba_ObjIsCi( Cba_Ntk_t * p, int i ) { return Cba_ObjIsPi(p, i) || Cba_ObjIsBo(p, i); }
static inline int Cba_ObjIsCo( Cba_Ntk_t * p, int i ) { return Cba_ObjIsPo(p, i) || Cba_ObjIsBi(p, i); }
static inline int Cba_ObjIsCio( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) < CBA_OBJ_BOX; }
static inline int Cba_ObjIsConst( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) >= CBA_BOX_CF && Cba_ObjType(p, i) <= CBA_BOX_CZ; }
static inline int Cba_ObjIsConstBin( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_BOX_CF || Cba_ObjType(p, i) == CBA_BOX_CT; }
static inline int Cba_ObjBit( Cba_Ntk_t * p, int i ) { assert(!Cba_ObjIsBox(p, i)); return Abc_LitIsCompl((int)Vec_StrEntry(&p->vType, i)); }
static inline void Cba_ObjSetBit( Cba_Ntk_t * p, int i ) { char *q = Vec_StrArray(&p->vType); assert(!Cba_ObjIsBox(p, i)); q[i] = (char)Abc_LitNot((int)q[i]); }
static inline int Cba_ObjFanin( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsCo(p, i)); return Vec_IntEntry(&p->vFanin, i); }
static inline int Cba_ObjIndex( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsCio(p, i)); return Vec_IntEntry(&p->vIndex, i); }
static inline int Cba_ObjNameInt( Cba_Ntk_t * p, int i ) { assert(!Cba_ObjIsCo(p, i)); return Vec_IntEntry(&p->vName, i); }
static inline int Cba_ObjName( Cba_Ntk_t * p, int i ) { return Cba_ObjIsCo(p, i) ? Cba_ObjNameInt(p, Cba_ObjFanin(p,i)) : Cba_ObjNameInt(p, i); }
static inline Cba_NameType_t Cba_ObjNameType( Cba_Ntk_t * p, int i ) { return Cba_NameType( Cba_ObjName(p, i) ); }
static inline int Cba_ObjNameId( Cba_Ntk_t * p, int i ) { return Abc_Lit2Var2( Cba_ObjName(p, i) ); }
static inline char * Cba_ObjNameStr( Cba_Ntk_t * p, int i ) { assert(Cba_ObjNameType(p, i) <= CBA_NAME_WORD); return Cba_NtkStr(p, Cba_ObjNameId(p, i)); }
static inline int Cba_ObjCopy( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vCopy, i); }
static inline int Cba_ObjFanout( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsCi(p, i)); return Vec_IntEntry(&p->vFanout, i); }
static inline int Cba_ObjNextFanout( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsCo(p, i)); return Vec_IntEntry(&p->vFanout, i); }
static inline void Cba_ObjSetFanout( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjIsCi(p, i)); Vec_IntSetEntry(&p->vFanout, i, x); }
static inline void Cba_ObjSetNextFanout( Cba_Ntk_t * p,int i,int x){ assert(Cba_ObjIsCo(p, i)); Vec_IntSetEntry(&p->vFanout, i, x); }
static inline void Cba_ObjCleanFanin( Cba_Ntk_t * p, int i ) { assert(Cba_ObjFanin(p, i) >= 0 && Cba_ObjIsCo(p, i)); Vec_IntSetEntry( &p->vFanin, i, -1); }
static inline void Cba_ObjSetFanin( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjFanin(p, i) == -1 && Cba_ObjIsCo(p, i)); Vec_IntSetEntry( &p->vFanin, i, x); }
static inline void Cba_ObjSetIndex( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjIndex(p, i) == -1); Vec_IntSetEntry( &p->vIndex, i, x ); }
static inline void Cba_ObjSetName( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjName(p, i) == 0 && !Cba_ObjIsCo(p, i)); Vec_IntSetEntry( &p->vName, i, x ); }
static inline void Cba_ObjSetCopy( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjCopy(p, i) == -1); Vec_IntSetEntry( &p->vCopy, i, x ); }
static inline int Cba_ObjGetConst( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsCi(p, i)); return Cba_ObjIsBo(p, i) && Cba_ObjIsConst(p, i-1) ? Cba_ObjType(p, i-1) : 0; }
static inline int Cba_BoxBiNum( Cba_Ntk_t * p, int i ) { int s = i-1; assert(Cba_ObjIsBox(p, i)); while (--i >= 0 && Cba_ObjIsBi(p, i)) {} return s - i; }
static inline int Cba_BoxBoNum( Cba_Ntk_t * p, int i ) { int s = i+1; assert(Cba_ObjIsBox(p, i)); while (++i < Cba_NtkObjNum(p) && Cba_ObjIsBo(p, i)) {} return i - s; }
static inline int Cba_BoxSize( Cba_Ntk_t * p, int i ) { return 1 + Cba_BoxBiNum(p, i) + Cba_BoxBoNum(p, i); }
static inline int Cba_BoxBi( Cba_Ntk_t * p, int b, int i ) { assert(Cba_ObjIsBox(p, b)); return b - 1 - i; }
static inline int Cba_BoxBo( Cba_Ntk_t * p, int b, int i ) { assert(Cba_ObjIsBox(p, b)); return b + 1 + i; }
//static inline int Cba_BoxBiBox( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBi(p, i)); return i + 1 + Cba_ObjIndex(p, i); }
static inline int Cba_BoxBoBox( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBo(p, i)); return i - 1 - Cba_ObjIndex(p, i); }
static inline int Cba_BoxFanin( Cba_Ntk_t * p, int b, int i ) { return Cba_ObjFanin(p, Cba_BoxBi(p, b, i)); }
static inline int Cba_BoxFaninBox( Cba_Ntk_t * p, int b, int i ) { return Cba_BoxBoBox(p, Cba_BoxFanin(p, b, i)); }
static inline int Cba_BoxBiRange( Cba_Ntk_t * p, int i ) { int s = i; assert(Cba_ObjIsBi(p, i) && !Cba_ObjBit(p, i)); while (--i >= 0 && Cba_ObjIsBi(p, i) && Cba_ObjBit(p, i)) {} return s - i; }
static inline int Cba_BoxBoRange( Cba_Ntk_t * p, int i ) { int s = i; assert(Cba_ObjIsBo(p, i) && !Cba_ObjBit(p, i)); while (++i < Cba_NtkObjNum(p) && Cba_ObjIsBo(p, i) && Cba_ObjBit(p, i)) {} return i - s; }
static inline int Cba_ObjPiRange( Cba_Ntk_t * p, int i ) { int s = i; assert(Cba_ObjIsPi(p, i) && !Cba_ObjBit(p, i)); while (++i < Cba_NtkObjNum(p) && Cba_ObjIsPi(p, i) && Cba_ObjBit(p, i)) {} return i - s; }
static inline int Cba_BoxNtkId( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBox(p, i)); return Vec_IntEntry(&p->vFanin, i); }
static inline void Cba_BoxSetNtkId( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjIsBox(p, i)&&Cba_ManNtkIsOk(p->pDesign, x));Vec_IntSetEntry(&p->vFanin, i, x);}
//static inline int Cba_BoxBiNtkId( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBi(p, i)); return Cba_BoxNtkId(p, Cba_BoxBiBox(p, i)); }
static inline int Cba_BoxBoNtkId( Cba_Ntk_t * p, int i ) { assert(Cba_ObjIsBo(p, i)); return Cba_BoxNtkId(p, Cba_BoxBoBox(p, i)); }
static inline Cba_Ntk_t * Cba_BoxNtk( Cba_Ntk_t * p, int i ) { return Cba_ManNtk( p->pDesign, Cba_BoxNtkId(p, i) ); }
//static inline Cba_Ntk_t * Cba_BoxBiNtk( Cba_Ntk_t * p, int i ) { return Cba_ManNtk( p->pDesign, Cba_BoxBiNtkId(p, i) ); }
static inline Cba_Ntk_t * Cba_BoxBoNtk( Cba_Ntk_t * p, int i ) { return Cba_ManNtk( p->pDesign, Cba_BoxBoNtkId(p, i) ); }
static inline char * Cba_BoxNtkName( Cba_Ntk_t * p, int i ) { return Abc_NamStr( p->pDesign->pMods, Cba_BoxNtkId(p, i) ); }
////////////////////////////////////////////////////////////////////////
/// MACRO DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
static inline int Cba_ObjFin0( Cba_Ntk_t * p, int i ) { assert(i>0); return Vec_IntEntry(&p->vObjFin0, i); }
static inline int Cba_ObjFon0( Cba_Ntk_t * p, int i ) { assert(i>0); return Vec_IntEntry(&p->vObjFon0, i); }
static inline int Cba_ObjFin( Cba_Ntk_t * p, int i, int k ) { assert(i>0); return Cba_ObjFin0(p, i) + k; }
static inline int Cba_ObjFon( Cba_Ntk_t * p, int i, int k ) { assert(i>0); return Cba_ObjFon0(p, i) + k; }
static inline int Cba_ObjFinNum( Cba_Ntk_t * p, int i ) { assert(i>0); return Cba_ObjFin0(p, i+1) - Cba_ObjFin0(p, i); }
static inline int Cba_ObjFonNum( Cba_Ntk_t * p, int i ) { assert(i>0); return Cba_ObjFon0(p, i+1) - Cba_ObjFon0(p, i); }
static inline int Cba_ObjCopy( Cba_Ntk_t * p, int i ) { assert(i>0); return Vec_IntGetEntryFull(&p->vObjCopy, i); }
static inline int Cba_ObjFunc( Cba_Ntk_t * p, int i ) { assert(i>0); return Vec_IntGetEntry(&p->vObjFunc, i); }
static inline int Cba_ObjName( Cba_Ntk_t * p, int i ) { assert(i>0); return Vec_IntGetEntry(&p->vObjName, i); }
static inline char * Cba_ObjNameStr( Cba_Ntk_t * p, int i ) { assert(i>0); return Cba_NtkStr(p, Cba_ObjName(p, i)); }
static inline int Cba_ObjAttr( Cba_Ntk_t * p, int i ) { assert(i>0); return Vec_IntGetEntry(&p->vObjAttr, i); }
static inline int * Cba_ObjAttrs( Cba_Ntk_t * p, int i ) { assert(i>0); return Vec_IntGetEntryP(&p->vObjAttr, i); }
static inline int Cba_ObjAttrSize( Cba_Ntk_t * p, int i ) { assert(i>0); return Vec_IntEntry(&p->vAttrSto, Vec_IntGetEntry(&p->vObjAttr, i)); }
static inline int * Cba_ObjAttrArray( Cba_Ntk_t * p, int i ) { assert(i>0); return Vec_IntEntryP(&p->vAttrSto, Vec_IntGetEntry(&p->vObjAttr, i)+1); }
static inline void Cba_ObjSetCopy( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjCopy(p, i) == -1); Vec_IntSetEntry( &p->vObjCopy, i, x ); }
static inline void Cba_ObjSetFunc( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjFunc(p, i) == 0); Vec_IntSetEntry( &p->vObjFunc, i, x ); }
static inline void Cba_ObjSetName( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjName(p, i) == 0); Vec_IntSetEntry( &p->vObjName, i, x ); }
static inline void Cba_ObjSetAttrs( Cba_Ntk_t * p, int i, int * a, int s ) { assert(Cba_ObjAttr(p, i) == 0); Vec_IntSetEntry(&p->vObjAttr, i, Vec_IntSize(&p->vAttrSto)); if (a) Vec_IntPushArray(&p->vAttrSto, a, s); }
static inline int Cba_FinFon( Cba_Ntk_t * p, int f ) { assert(f>0); return Vec_IntEntry(&p->vFinFon, f); }
static inline int Cba_ObjFinFon( Cba_Ntk_t * p, int i, int k ) { assert(i>0); return Cba_FinFon(p, Cba_ObjFin(p, i, k)); }
static inline int * Cba_ObjFinFons( Cba_Ntk_t * p, int i ) { assert(i>0); return Vec_IntEntryP(&p->vFinFon, Cba_ObjFin0(p, i)); }
static inline void Cba_ObjSetFinFon( Cba_Ntk_t * p, int i, int k, int x ) { assert(i>0); assert(Cba_ObjFinFon(p, i, k)== 0); Vec_IntWriteEntry(&p->vFinFon, Cba_ObjFin(p, i, k), x); }
static inline void Cba_ObjCleanFinFon( Cba_Ntk_t * p, int i, int k) { assert(i>0); assert(Cba_ObjFinFon(p, i, k) > 0); Vec_IntWriteEntry(&p->vFinFon, Cba_ObjFin(p, i, k), 0); }
static inline void Cba_ObjPatchFinFon( Cba_Ntk_t * p, int i, int k, int x){ assert(i>0); Cba_ObjCleanFinFon(p, i, k); Cba_ObjSetFinFon(p, i, k, x); }
static inline int Cba_ObjNtkId( Cba_Ntk_t * p, int i ) { assert(i>0 && Cba_NtkHasObjFuncs(p)); return Cba_ObjIsBoxUser(p, i) ? Cba_ObjFunc(p, i) : 0;}
static inline Cba_Ntk_t * Cba_ObjNtk( Cba_Ntk_t * p, int i ) { assert(i>0); return Cba_NtkNtk(p, Cba_ObjNtkId(p, i)); }
static inline int Cba_ObjSetNtkId( Cba_Ntk_t * p, int i, int x ) { assert(i>0); assert(Cba_ObjIsBoxUser(p, i)); Cba_ObjSetFunc( p, i, x ); }
static inline int Cba_FonIsReal( int f ) { return f > 0; }
static inline int Cba_FonIsConst( int f ) { return f < 0; }
static inline int Cba_FonConst( int f ) { assert(Cba_FonIsConst(f)); return -f-1; }
static inline int Cba_FonFromConst( int c ) { assert(c >= 0); return -c-1; }
static inline int Cba_FonObj( Cba_Ntk_t * p, int f ) { return Cba_FonIsReal(f) ? Vec_IntEntry(&p->vFonObj, f) : 0; }
static inline int Cba_FonCopy( Cba_Ntk_t * p, int f ) { return Cba_FonIsReal(f) ? Vec_IntEntry( &p->vFonCopy, f ) : f; }
static inline void Cba_FonSetCopy( Cba_Ntk_t * p, int f, int x ) { assert(Cba_FonIsReal(f)); assert(Cba_FonCopy(p, f) == 0); Vec_IntWriteEntry(&p->vFonCopy, f, x); }
static inline int Cba_FonName( Cba_Ntk_t * p, int f ) { assert(Cba_FonIsReal(f)); return Vec_IntGetEntry( &p->vFonName, f ); }
static inline char * Cba_FonNameStr( Cba_Ntk_t * p, int f ) { assert(Cba_FonIsReal(f)); return Cba_NtkStr(p, Cba_FonName(p, f)); }
static inline void Cba_FonSetName( Cba_Ntk_t * p, int f, int x ) { assert(Cba_FonIsReal(f)); assert(Cba_FonName(p, f) == 0); Vec_IntSetEntry(&p->vFonName, f, x); }
static inline void Cba_FonCleanName( Cba_Ntk_t * p, int f ) { assert(Cba_FonIsReal(f)); assert(Cba_FonName(p, f) != 0); Vec_IntSetEntry(&p->vFonName, f, 0); }
static inline void Cba_FonPatchName( Cba_Ntk_t * p, int f, int x) { assert(Cba_FonIsReal(f)); Cba_FonCleanName(p, f); Cba_FonSetName(p, f, x); }
static inline int Cba_FonIndex( Cba_Ntk_t * p, int f ) { assert(Cba_FonIsReal(f)); return f - Cba_ObjFon0( p, Cba_FonObj(p, f) ); }
static inline int Cba_FonNtkId( Cba_Ntk_t * p, int f ) { assert(Cba_FonIsReal(f)); return Cba_ObjNtkId( p, Cba_FonObj(p, f) ); }
static inline Cba_Ntk_t * Cba_FonNtk( Cba_Ntk_t * p, int f ) { assert(Cba_FonIsReal(f)); return Cba_ObjNtk( p, Cba_FonObj(p, f) ); }
static inline int Cba_ObjFanin( Cba_Ntk_t * p, int i, int k ) { assert(i>0); return Cba_FonObj( p, Cba_ObjFinFon(p, i, k) ); }
////////////////////////////////////////////////////////////////////////
/// ITERATORS ///
......@@ -338,61 +357,41 @@ static inline char * Cba_BoxNtkName( Cba_Ntk_t * p, int i ) { r
for ( i = 0; (i < Cba_NtkPiNum(p)) && (((iObj) = Cba_NtkPi(p, i)), 1); i++ )
#define Cba_NtkForEachPo( p, iObj, i ) \
for ( i = 0; (i < Cba_NtkPoNum(p)) && (((iObj) = Cba_NtkPo(p, i)), 1); i++ )
#define Cba_NtkForEachPoDriver( p, iObj, i ) \
for ( i = 0; (i < Cba_NtkPoNum(p)) && (((iObj) = Cba_ObjFanin(p, Cba_NtkPo(p, i))), 1); i++ )
#define Cba_NtkForEachPiMain( p, iObj, i ) \
for ( i = 0; (i < Cba_NtkPiNum(p)) && (((iObj) = Cba_NtkPi(p, i)), 1); i++ ) if ( Cba_ObjBit(p, iObj) ) {} else
#define Cba_NtkForEachPoMain( p, iObj, i ) \
for ( i = 0; (i < Cba_NtkPoNum(p)) && (((iObj) = Cba_NtkPo(p, i)), 1); i++ ) if ( Cba_ObjBit(p, iObj) ) {} else
#define Cba_NtkForEachPiFon( p, iObj, iFon, i ) \
for ( i = 0; (i < Cba_NtkPiNum(p)) && (((iObj) = Cba_NtkPi(p, i)), 1) && (((iFon) = Cba_ObjFon0(p, iObj)), 1); i++ )
#define Cba_NtkForEachPoDriverFon( p, iObj, iFon, i ) \
for ( i = 0; (i < Cba_NtkPoNum(p)) && (((iObj) = Cba_NtkPo(p, i)), 1) && (((iFon) = Cba_ObjFinFon(p, iObj, 0)), 1); i++ )
#define Cba_NtkForEachPoDriver( p, iObj, i ) \
for ( i = 0; (i < Cba_NtkPoNum(p)) && (((iObj) = Cba_ObjFanin(p, Cba_NtkPo(p, i), 0)), 1); i++ )
#define Cba_NtkForEachObj( p, i ) if ( !Cba_ObjType(p, i) ) {} else \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ )
#define Cba_NtkForEachObj( p, i ) \
for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Cba_ObjType(p, i) ) {} else
#define Cba_NtkForEachObjType( p, Type, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)) && (((Type) = Cba_ObjType(p, i)), 1); i++ ) if ( !Type ) {} else
for ( i = 1; i < Vec_StrSize(&p->vObjType) && (((Type) = Cba_ObjType(p, i)), 1); i++ ) if ( !Type ) {} else
#define Cba_NtkForEachBox( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsBox(p, i) ) {} else
for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Cba_ObjIsBox(p, i) ) {} else
#define Cba_NtkForEachBoxUser( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsBoxUser(p, i) ) {} else
for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Cba_ObjIsBoxUser(p, i) ) {} else
#define Cba_NtkForEachBoxPrim( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsBoxPrim(p, i) ) {} else
#define Cba_NtkForEachCi( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsCi(p, i) ) {} else
#define Cba_NtkForEachCo( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsCo(p, i) ) {} else
#define Cba_NtkForEachCio( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsCio(p, i) ){} else
#define Cba_NtkForEachBi( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsBi(p, i) ){} else
#define Cba_NtkForEachBo( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsBo(p, i) ){} else
#define Cba_NtkForEachBio( p, i ) \
for ( i = 0; (i < Cba_NtkObjNum(p)); i++ ) if ( !Cba_ObjIsBio(p, i) ){} else
#define Cba_BoxForEachBi( p, iBox, iTerm, i ) \
for ( iTerm = iBox - 1, i = 0; iTerm >= 0 && Cba_ObjIsBi(p, iTerm); iTerm--, i++ )
#define Cba_BoxForEachBo( p, iBox, iTerm, i ) \
for ( iTerm = iBox + 1, i = 0; iTerm < Cba_NtkObjNum(p) && Cba_ObjIsBo(p, iTerm); iTerm++, i++ )
#define Cba_BoxForEachBiReverse( p, iBox, iTerm, i ) \
for ( i = Cba_BoxBiNum(p, iBox), iTerm = iBox - i--; Cba_ObjIsBi(p, iTerm); iTerm++, i-- )
#define Cba_BoxForEachBiMain( p, iBox, iTerm, i ) \
for ( iTerm = iBox - 1, i = 0; iTerm >= 0 && Cba_ObjIsBi(p, iTerm); iTerm--, i++ ) if ( Cba_ObjBit(p, iTerm) ) {} else
#define Cba_BoxForEachBoMain( p, iBox, iTerm, i ) \
for ( iTerm = iBox + 1, i = 0; iTerm < Cba_NtkObjNum(p) && Cba_ObjIsBo(p, iTerm); iTerm++, i++ ) if ( Cba_ObjBit(p, iTerm) ) {} else
#define Cba_BoxForEachFanin( p, iBox, iFanin, i ) \
for ( i = 0; iBox - 1 - i >= 0 && Cba_ObjIsBi(p, iBox - 1 - i) && (((iFanin) = Cba_BoxFanin(p, iBox, i)), 1); i++ )
#define Cba_BoxForEachFaninBox( p, iBox, iFanin, i ) \
for ( i = 0; iBox - 1 - i >= 0 && Cba_ObjIsBi(p, iBox - 1 - i) && (((iFanin) = Cba_BoxFaninBox(p, iBox, i)), 1); i++ )
#define Cba_ObjForEachFanout( p, iCi, iCo ) \
for ( iCo = Cba_ObjFanout(p, iCi); iCo; iCo = Cba_ObjNextFanout(p, iCo) )
#define Cba_BoxForEachFanoutBox( p, iBox, iCo, iFanBox ) \
for ( assert(Cba_BoxBoNum(p, iBox) == 1), iCo = Cba_ObjFanout(p, Cba_BoxBo(p, iBox, 0)); iCo && ((iFanBox = Cba_BoxBiBox(p, iCo)), 1); iCo = Cba_ObjNextFanout(p, iCo) )
for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Cba_ObjIsBoxPrim(p, i) ) {} else
#define Cba_NtkForEachFinFon( p, iFon, i ) \
for ( i = 0; i < Vec_IntSize(&p->vFinFon) && (((iFon) = Vec_IntEntry(&p->vFinFon, i)), 1); i++ ) if ( !iFon ) {} else
#define Cba_NtkForEachFonName( p, Name, i ) \
for ( i = 0; i < Vec_IntSize(&p->vFonName) && (((Name) = Vec_IntEntry(&p->vFonName, i)), 1); i++ ) if ( !Name ) {} else
#define Cba_ObjForEachFin( p, iObj, iFin, k ) \
for ( k = 0, iFin = Cba_ObjFin0(p, iObj); iFin < Cba_ObjFin0(p, iObj+1); iFin++, k++ )
#define Cba_ObjForEachFon( p, iObj, iFon, k ) \
for ( k = 0, iFon = Cba_ObjFon0(p, iObj); iFon < Cba_ObjFon0(p, iObj+1); iFon++, k++ )
#define Cba_ObjForEachFinFon( p, iObj, iFin, iFon, k ) \
for ( k = 0, iFin = Cba_ObjFin0(p, iObj); iFin < Cba_ObjFin0(p, iObj+1) && ((iFon = Cba_FinFon(p, iFin)), 1); iFin++, k++ )
#define Cba_ObjForEachFinFanin( p, iObj, iFin, iFanin, k ) \
for ( k = 0, iFin = Cba_ObjFin0(p, iObj); iFin < Cba_ObjFin0(p, iObj+1) && ((iFanin = Cba_FonObj(p, Cba_FinFon(p, iFin))), 1); iFin++, k++ )
#define Cba_ObjForEachFinFaninReal( p, iObj, iFin, iFanin, k ) \
for ( k = 0, iFin = Cba_ObjFin0(p, iObj); iFin < Cba_ObjFin0(p, iObj+1) && ((iFanin = Cba_FonObj(p, Cba_FinFon(p, iFin))), 1); iFin++, k++ ) if ( !iFanin ) {} else
////////////////////////////////////////////////////////////////////////
/// FUNCTION DECLARATIONS ///
......@@ -409,114 +408,40 @@ static inline char * Cba_BoxNtkName( Cba_Ntk_t * p, int i ) { r
SeeAlso []
***********************************************************************/
static inline int Cba_ObjAlloc( Cba_Ntk_t * p, Cba_ObjType_t Type, int Fanin )
static inline int Cba_ObjAlloc( Cba_Ntk_t * p, Cba_ObjType_t Type, int nFins, int nFons )
{
int iObj = Cba_NtkObjNum(p);
assert( iObj == Vec_IntSize(&p->vFanin) );
int i, iObj = Vec_StrSize(&p->vObjType);
if ( Type == CBA_OBJ_PI )
Vec_IntPush( &p->vInputs, iObj );
else if ( Type == CBA_OBJ_PO )
Vec_IntPush( &p->vOutputs, iObj );
Vec_StrPush( &p->vType, (char)Abc_Var2Lit(Type, 0) );
Vec_IntPush( &p->vFanin, Fanin );
Vec_StrPush( &p->vObjType, (char)Type );
// add fins
for ( i = 0; i < nFins; i++ )
Vec_IntPush( &p->vFinFon, 0 );
if ( Vec_IntSize(&p->vObjFin0) )
Vec_IntPush( &p->vObjFin0, Vec_IntSize(&p->vFinFon) );
// add fons
for ( i = 0; i < nFons; i++ )
Vec_IntPush( &p->vFonObj, iObj );
if ( Vec_IntSize(&p->vObjFon0) )
Vec_IntPush( &p->vObjFon0, Vec_IntSize(&p->vFonObj) );
return iObj;
}
static inline int Cba_ObjDup( Cba_Ntk_t * pNew, Cba_Ntk_t * p, int i )
{
int iObj = Cba_ObjAlloc( pNew, Cba_ObjType(p, i), Cba_ObjIsBox(p, i) ? Cba_BoxNtkId(p, i) : -1 );
if ( Cba_NtkHasNames(p) && Cba_NtkHasNames(pNew) && !Cba_ObjIsCo(p, i) )
Cba_ObjSetName( pNew, iObj, Cba_ObjName(p, i) );
int iObj = Cba_ObjAlloc( pNew, Cba_ObjType(p, i), Cba_ObjFinNum(p, i), Cba_ObjFonNum(p, i) );
Cba_ObjSetCopy( p, i, iObj );
return iObj;
}
static inline int Cba_BoxAlloc( Cba_Ntk_t * p, Cba_ObjType_t Type, int nIns, int nOuts, int iNtk )
{
int i, iObj;
for ( i = nIns - 1; i >= 0; i-- )
Cba_ObjAlloc( p, CBA_OBJ_BI, -1 );
iObj = Cba_ObjAlloc( p, Type, iNtk );
for ( i = 0; i < nOuts; i++ )
Cba_ObjAlloc( p, CBA_OBJ_BO, -1 );
return iObj;
}
static inline int Cba_BoxDup( Cba_Ntk_t * pNew, Cba_Ntk_t * p, int iBox )
{
int i, iTerm, iBoxNew;
Cba_BoxForEachBiReverse( p, iBox, iTerm, i )
Cba_ObjDup( pNew, p, iTerm );
iBoxNew = Cba_ObjDup( pNew, p, iBox );
if ( Cba_NtkHasNames(p) && Cba_NtkHasNames(pNew) && Cba_ObjName(p, iBox) )
Cba_ObjSetName( pNew, iBoxNew, Cba_ObjName(p, iBox) );
if ( Cba_BoxNtk(p, iBox) )
Cba_BoxSetNtkId( pNew, iBoxNew, Cba_NtkCopy(Cba_BoxNtk(p, iBox)) );
Cba_BoxForEachBo( p, iBox, iTerm, i )
Cba_ObjDup( pNew, p, iTerm );
return iBoxNew;
}
static inline void Cba_BoxDelete( Cba_Ntk_t * p, int iBox )
{
int iStart = iBox - Cba_BoxBiNum(p, iBox);
int i, iStop = iBox + Cba_BoxBoNum(p, iBox);
for ( i = iStart; i <= iStop; i++ )
{
Vec_StrWriteEntry( &p->vType, i, (char)0 );
Vec_IntWriteEntry( &p->vFanin, i, -1 );
if ( Cba_NtkHasNames(p) )
Vec_IntWriteEntry( &p->vName, i, 0 );
if ( Cba_NtkHasFanouts(p) )
Vec_IntWriteEntry( &p->vFanout, i, 0 );
}
}
static inline void Cba_BoxReplace( Cba_Ntk_t * p, int iBox, int * pArray, int nSize )
{
extern void Cba_NtkUpdateFanout( Cba_Ntk_t * p, int iOld, int iNew );
int i, Limit = Cba_BoxBoNum(p, iBox);
assert( Limit == nSize );
for ( i = 0; i < Limit; i++ )
Cba_NtkUpdateFanout( p, Cba_BoxBo(p, iBox, i), pArray[i] );
}
static inline Vec_Int_t * Cba_BoxCollectRanges( Cba_Ntk_t * p, int iBox )
{
static Vec_Int_t Bits, * vBits = &Bits;
static int pArray[10]; int i, iTerm;
assert( !Cba_ObjIsBoxUser(p, iBox) );
// initialize array
vBits->pArray = pArray;
vBits->nSize = 0;
vBits->nCap = 10;
// iterate through inputs
Cba_BoxForEachBiMain( p, iBox, iTerm, i )
Vec_IntPush( vBits, Cba_BoxBiRange(p, iTerm) );
// iterate through outputs
Cba_BoxForEachBoMain( p, iBox, iTerm, i )
Vec_IntPush( vBits, Cba_BoxBoRange(p, iTerm) );
assert( Vec_IntSize(vBits) < 10 );
//Vec_IntPrint( vBits );
return vBits;
}
/**Function*************************************************************
Synopsis [Prints vector.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline void Vec_StrPrint( Vec_Str_t * p, int fInt )
static inline void Cba_ObjDelete( Cba_Ntk_t * p, int i )
{
int i;
for ( i = 0; i < p->nSize; i++ )
if ( fInt )
printf( "%d ", (int)p->pArray[i] );
else
printf( "%c ", p->pArray[i] );
printf( "\n" );
int k, iFin, iFon;
Cba_ObjCleanType( p, i );
Cba_ObjForEachFin( p, i, iFin, k )
Vec_IntWriteEntry( &p->vFinFon, iFin, 0 );
Cba_ObjForEachFon( p, i, iFon, k )
Vec_IntWriteEntry( &p->vFonObj, iFon, 0 );
}
/**Function*************************************************************
......@@ -530,181 +455,287 @@ static inline void Vec_StrPrint( Vec_Str_t * p, int fInt )
SeeAlso []
***********************************************************************/
static inline void Cba_NtkAlloc( Cba_Ntk_t * pNew, int NameId, int nIns, int nOuts, int nObjs )
static inline Cba_Ntk_t * Cba_NtkAlloc( Cba_Man_t * p, int NameId, int nIns, int nOuts, int nObjs, int nFins, int nFons )
{
int NtkId, fFound;
assert( pNew->pDesign != NULL );
assert( Cba_NtkPiNum(pNew) == 0 );
assert( Cba_NtkPoNum(pNew) == 0 );
Cba_Ntk_t * pNew = ABC_CALLOC( Cba_Ntk_t, 1 );
assert( nIns >= 0 && nOuts >= 0 && nObjs >= 0 && nFins >= 0 && nFons >= 0 );
pNew->Id = Vec_PtrSize(&p->vNtks); Vec_PtrPush( &p->vNtks, pNew );
pNew->NameId = NameId;
pNew->iCopy = -1;
pNew->iBoxNtk = -1;
pNew->iBoxObj = -1;
pNew->pDesign = p;
Vec_IntGrow( &pNew->vInputs, nIns );
Vec_IntGrow( &pNew->vOutputs, nOuts );
Vec_StrGrow( &pNew->vType, nObjs );
Vec_IntGrow( &pNew->vFanin, nObjs );
// check if the network is unique
NtkId = Abc_NamStrFindOrAdd( pNew->pDesign->pMods, Cba_NtkStr(pNew, NameId), &fFound );
Vec_StrGrow( &pNew->vObjType, nObjs+1 ); Vec_StrPush( &pNew->vObjType, (char)CBA_OBJ_NONE );
Vec_IntGrow( &pNew->vObjFin0, nObjs+2 ); Vec_IntPush( &pNew->vObjFin0, 0 ); Vec_IntPush( &pNew->vObjFin0, 1 );
Vec_IntGrow( &pNew->vObjFon0, nObjs+2 ); Vec_IntPush( &pNew->vObjFon0, 0 ); Vec_IntPush( &pNew->vObjFon0, 1 );
Vec_IntGrow( &pNew->vFinFon, nFins+1 ); Vec_IntPush( &pNew->vFinFon, 0 );
Vec_IntGrow( &pNew->vFonObj, nFons+1 ); Vec_IntPush( &pNew->vFonObj, 0 );
return pNew;
}
static inline void Cba_NtkAdd( Cba_Man_t * p, Cba_Ntk_t * pNtk )
{
int fFound, NtkId = Abc_NamStrFindOrAdd( p->pMods, Cba_NtkStr(pNtk, pNtk->NameId), &fFound );
if ( fFound )
printf( "Network with name %s already exists.\n", Cba_NtkStr(pNew, NameId) );
printf( "Network with name \"%s\" already exists.\n", Cba_NtkStr(pNtk, pNtk->NameId) );
else
assert( NtkId == Cba_NtkId(pNew) );
assert( NtkId == pNtk->Id );
}
static inline void Cba_NtkDup( Cba_Ntk_t * pNew, Cba_Ntk_t * p )
static inline Vec_Int_t * Cba_NtkCollect( Cba_Ntk_t * p )
{
int i, iObj;
assert( pNew != p );
Cba_NtkAlloc( pNew, Cba_NtkNameId(p), Cba_NtkPiNum(p), Cba_NtkPoNum(p), Cba_NtkObjNum(p) );
if ( Vec_IntSize(&p->vInfo) )
Vec_IntAppend( &pNew->vInfo, &p->vInfo );
Cba_NtkStartCopies( p );
if ( Cba_NtkHasNames(p) )
Cba_NtkStartNames( pNew );
int iObj;
Vec_Int_t * vObjs = Vec_IntAlloc( Cba_NtkObjNum(p) );
Cba_NtkForEachObj( p, iObj )
Vec_IntPush( vObjs, iObj );
return vObjs;
}
static inline void Cba_NtkCollectDfs_rec( Cba_Ntk_t * p, int iObj, Vec_Int_t * vObjs )
{
int iFin, iFanin, k;
if ( !Cba_ObjCopy(p, iObj) )
return;
Cba_ObjSetCopy( p, iObj, 0 );
Cba_ObjForEachFinFaninReal( p, iObj, iFin, iFanin, k )
Cba_NtkCollectDfs_rec( p, iFanin, vObjs );
Vec_IntPush( vObjs, iObj );
}
static inline Vec_Int_t * Cba_NtkCollectDfs( Cba_Ntk_t * p )
{
int i, k, iObj, iFin, iFanin;
Vec_Int_t * vObjs = Vec_IntAlloc( Cba_NtkObjNum(p) );
// collect PIs
Cba_NtkForEachPi( p, iObj, i )
Cba_ObjDup( pNew, p, iObj );
Cba_NtkForEachBox( p, iObj )
Cba_BoxDup( pNew, p, iObj );
Vec_IntPush( vObjs, iObj );
// prepare leaves
Cba_NtkCleanObjCopies( p );
Vec_IntForEachEntry( vObjs, iObj, i )
Cba_ObjSetCopy( p, iObj, 0 );
// collect internal
Cba_NtkForEachPo( p, iObj, i )
Cba_ObjDup( pNew, p, iObj );
Cba_NtkForEachCo( p, iObj )
Cba_ObjSetFanin( pNew, Cba_ObjCopy(p, iObj), Cba_ObjCopy(p, Cba_ObjFanin(p, iObj)) );
//Cba_NtkFreeCopies( p ); // needed for name transfer and host ntk
assert( Cba_NtkObjNum(pNew) == Cba_NtkObjNumAlloc(pNew) );
Cba_ObjForEachFinFaninReal( p, iObj, iFin, iFanin, k )
Cba_NtkCollectDfs_rec( p, iFanin, vObjs );
// additionally collect user modules without outputs
Cba_NtkForEachBoxUser( p, iObj )
if ( Cba_ObjFonNum(p, iObj) == 0 )
Cba_ObjForEachFinFaninReal( p, iObj, iFin, iFanin, k )
Cba_NtkCollectDfs_rec( p, iFanin, vObjs );
// collect POs
Cba_NtkForEachPo( p, iObj, i )
Vec_IntPush( vObjs, iObj );
// collect user boxes without fanouts
Cba_NtkForEachBoxUser( p, iObj )
if ( Cba_ObjFonNum(p, iObj) == 0 )
Vec_IntPush( vObjs, iObj );
assert( Vec_IntSize(vObjs) <= Cba_NtkObjNum(p) );
if ( Vec_IntSize(vObjs) != Cba_NtkObjNum(p) )
printf( "Warning: DSF ordering collected %d out of %d objects.\n", Vec_IntSize(vObjs), Cba_NtkObjNum(p) );
return vObjs;
}
static inline void Cba_NtkDupUserBoxes( Cba_Ntk_t * pNew, Cba_Ntk_t * p )
static inline void Cba_NtkCreateFonNames( Cba_Ntk_t * p, char * pPref )
{
int i, iObj;
assert( pNew != p );
Cba_NtkAlloc( pNew, Cba_NtkNameId(p), Cba_NtkPiNum(p), Cba_NtkPoNum(p), Cba_NtkObjNum(p) + 3*Cba_NtkCoNum(p) );
if ( Vec_IntSize(&p->vInfo) )
Vec_IntAppend( &pNew->vInfo, &p->vInfo );
Cba_NtkStartCopies( p );
int i, iObj, NameId;
Cba_NtkCleanFonNames( p );
Cba_NtkForEachPi( p, iObj, i )
Cba_ObjDup( pNew, p, iObj );
Cba_FonSetName( p, Cba_ObjFon0(p, iObj), Cba_ObjName(p, iObj) );
Cba_NtkForEachPo( p, iObj, i )
Cba_ObjDup( pNew, p, iObj );
Cba_NtkForEachBoxUser( p, iObj )
Cba_BoxDup( pNew, p, iObj );
// connect feed-throughs
Cba_NtkForEachCo( p, iObj )
if ( Cba_ObjCopy(p, iObj) >= 0 && Cba_ObjCopy(p, Cba_ObjFanin(p, iObj)) >= 0 )
Cba_ObjSetFanin( pNew, Cba_ObjCopy(p, iObj), Cba_ObjCopy(p, Cba_ObjFanin(p, iObj)) );
Cba_FonSetName( p, Cba_ObjFinFon(p, iObj, 0), Cba_ObjName(p, iObj) );
Vec_IntForEachEntryStart( &p->vFonName, NameId, i, 1 )
if ( NameId == 0 )
Vec_IntWriteEntry( &p->vFonName, i, Cba_ManNewStrId(p->pDesign, pPref, i, NULL) );
}
static inline void Cba_NtkMoveNames( Cba_Ntk_t * pNew, Cba_Ntk_t * p )
static inline void Cba_NtkMissingFonNames( Cba_Ntk_t * p, char * pPref )
{
int i, iBox, iObj;
assert( Cba_NtkHasNames(p) );
assert( !Cba_NtkHasNames(pNew) );
Cba_NtkStartNames( pNew );
int i, iObj, iFon;
Cba_NtkForEachPi( p, iObj, i )
Cba_ObjSetName( pNew, Cba_ObjCopy(p, iObj), Cba_ObjName(p, iObj) );
Cba_NtkForEachBoxUser( p, iBox )
if ( !Cba_FonName(p, Cba_ObjFon0(p, iObj)) )
Cba_FonSetName( p, Cba_ObjFon0(p, iObj), Cba_ObjName(p, iObj) );
Cba_NtkForEachPo( p, iObj, i )
if ( Cba_ObjFinFon(p, iObj, 0) > 0 && !Cba_FonName(p, Cba_ObjFinFon(p, iObj, 0)) )
Cba_FonSetName( p, Cba_ObjFinFon(p, iObj, 0), Cba_ObjName(p, iObj) );
Cba_NtkForEachObj( p, iObj )
Cba_ObjForEachFon( p, iObj, iFon, i )
if ( !Cba_FonName(p, iFon) )
Cba_FonSetName( p, iFon, Cba_ManNewStrId(p->pDesign, pPref, iFon, NULL) );
}
static inline void Cba_NtkCountParams( Cba_Ntk_t * p, Vec_Int_t * vObjs, int * nPis, int * nPos, int * nFins, int * nFons )
{
int i, iObj;
*nPis = *nPos = *nFins = *nFons = 0;
Vec_IntForEachEntry( vObjs, iObj, i )
{
Cba_ObjSetName( pNew, Cba_ObjCopy(p, iBox), Cba_ObjName(p, iBox) );
Cba_BoxForEachBo( p, iBox, iObj, i )
Cba_ObjSetName( pNew, Cba_ObjCopy(p, iObj), Cba_ObjName(p, iObj) );
*nPis += Cba_ObjIsPi(p, iObj);
*nPos += Cba_ObjIsPo(p, iObj);
*nFins += Cba_ObjFinNum(p, iObj);
*nFons += Cba_ObjFonNum(p, iObj);
}
Cba_NtkForEachBoxUser( p, iBox )
Cba_BoxForEachBi( p, iBox, iObj, i )
if ( !Cba_ObjName(pNew, Cba_ObjFanin(pNew, Cba_ObjCopy(p, iObj))) )
Cba_ObjSetName( pNew, Cba_ObjFanin(pNew, Cba_ObjCopy(p, iObj)), Cba_ObjName(p, iObj) );
Cba_NtkForEachPo( p, iObj, i )
if ( !Cba_ObjName(pNew, Cba_ObjFanin(pNew, Cba_ObjCopy(p, iObj))) )
Cba_ObjSetName( pNew, Cba_ObjFanin(pNew, Cba_ObjCopy(p, iObj)), Cba_ObjName(p, iObj) );
}
static inline Cba_Ntk_t * Cba_NtkDup( Cba_Man_t * pMan, Cba_Ntk_t * p, Vec_Int_t * vObjs )
{
Cba_Ntk_t * pNew;
int i, k, iObj, iObjNew, iFin, iFon;
int nPis, nPos, nFins, nFons;
Cba_NtkCountParams( p, vObjs, &nPis, &nPos, &nFins, &nFons );
pNew = Cba_NtkAlloc( pMan, 0, nPis, nPos, Vec_IntSize(vObjs), nFins, nFons );
Cba_NtkAdd( pMan, pNew );
Cba_NtkCleanObjCopies( p );
Cba_NtkCleanFonCopies( p );
Vec_IntForEachEntry( vObjs, iObj, i )
{
iObjNew = Cba_ObjDup( pNew, p, iObj );
Cba_ObjForEachFon( p, iObj, iFon, k )
Cba_FonSetCopy( p, iFon, Cba_ObjFon(pNew, iObjNew, k) );
}
Vec_IntForEachEntry( vObjs, iObj, i )
{
iObjNew = Cba_ObjCopy( p, iObj );
Cba_ObjForEachFinFon( p, iObj, iFin, iFon, k )
Cba_ObjSetFinFon( pNew, iObjNew, k, Cba_FonCopy(p, iFon) );
}
//Cba_NtkFreeObjCopies( p );
//Cba_NtkFreeFonCopies( p );
assert( Cba_NtkObjNum(pNew) == Cba_NtkObjNumAlloc(pNew) );
Cba_NtkSetCopy( p, Cba_NtkId(pNew) );
return pNew;
}
static inline Cba_Ntk_t * Cba_NtkDupOrder( Cba_Man_t * pMan, Cba_Ntk_t * p, Vec_Int_t*(* pFuncOrder)(Cba_Ntk_t*) )
{
Cba_Ntk_t * pNew;
Vec_Int_t * vObjs = pFuncOrder ? pFuncOrder(p) : Cba_NtkCollect(p);
if ( vObjs == NULL )
return NULL;
pNew = Cba_NtkDup( pMan, p, vObjs );
Vec_IntFree( vObjs );
return pNew;
}
static inline Cba_Ntk_t * Cba_NtkDupAttrs( Cba_Ntk_t * pNew, Cba_Ntk_t * p )
{
// transfer object attributes
Vec_IntRemapArray( &p->vObjCopy, &p->vObjFunc, &pNew->vObjFunc, Cba_NtkObjNum(pNew) + 1 );
Vec_IntRemapArray( &p->vObjCopy, &p->vObjName, &pNew->vObjName, Cba_NtkObjNum(pNew) + 1 );
Vec_IntRemapArray( &p->vObjCopy, &p->vObjAttr, &pNew->vObjAttr, Cba_NtkObjNum(pNew) + 1 );
// transfer fon attributes
Vec_IntRemapArray( &p->vFonCopy, &p->vFonName, &pNew->vFonName, Cba_NtkFonNum(pNew) + 1 );
Vec_IntRemapArray( &p->vFonCopy, &p->vFonRange, &pNew->vFonRange, Cba_NtkFonNum(pNew) + 1 );
Vec_IntRemapArray( &p->vFonCopy, &p->vFonLeft, &pNew->vFonLeft, Cba_NtkFonNum(pNew) + 1 );
Vec_IntRemapArray( &p->vFonCopy, &p->vFonRight, &pNew->vFonRight, Cba_NtkFonNum(pNew) + 1 );
// duplicate attributes
Vec_IntAppend( &pNew->vAttrSto, &p->vAttrSto );
pNew->vOther = p->vOther ? (Vec_Ptr_t *)Vec_VecDup( (Vec_Vec_t *)p->vOther ) : NULL;
}
static inline void Cba_NtkFree( Cba_Ntk_t * p )
{
// interface
Vec_IntErase( &p->vInputs );
Vec_IntErase( &p->vOutputs );
Vec_IntErase( &p->vInfo );
Vec_StrErase( &p->vType );
Vec_IntErase( &p->vFanin );
Vec_IntErase( &p->vIndex );
Vec_IntErase( &p->vName );
Vec_IntErase( &p->vFanout );
Vec_IntErase( &p->vCopy );
Vec_IntErase( &p->vArray );
Vec_IntErase( &p->vArray2 );
Vec_IntErase( &p->vOrder );
// stucture
Vec_StrErase( &p->vObjType );
Vec_IntErase( &p->vObjFin0 );
Vec_IntErase( &p->vObjFon0 );
Vec_IntErase( &p->vFinFon );
Vec_IntErase( &p->vFonObj );
// optional
Vec_IntErase( &p->vObjCopy );
Vec_IntErase( &p->vObjFunc );
Vec_IntErase( &p->vObjName );
Vec_IntErase( &p->vObjAttr );
Vec_IntErase( &p->vAttrSto );
Vec_IntErase( &p->vFonCopy );
Vec_IntErase( &p->vFonName );
Vec_IntErase( &p->vFonRange );
Vec_IntErase( &p->vFonLeft );
Vec_IntErase( &p->vFonRight );
Vec_IntErase( &p->vFonPrev );
Vec_IntErase( &p->vFonNext );
Vec_IntErase( &p->vFinFon0 );
Vec_IntErase( &p->vFinObj );
Vec_IntErase( &p->vNtkObjs );
// other
Vec_IntErase( &p->vArray0 );
Vec_IntErase( &p->vArray1 );
if ( p->vOther ) Vec_VecFree( (Vec_Vec_t *)p->vOther );
ABC_FREE( p );
}
static inline int Cba_NtkMemory( Cba_Ntk_t * p )
{
int nMem = sizeof(Cba_Ntk_t);
// interface
nMem += (int)Vec_IntMemory(&p->vInputs);
nMem += (int)Vec_IntMemory(&p->vOutputs);
nMem += (int)Vec_IntMemory(&p->vInfo);
nMem += (int)Vec_StrMemory(&p->vType);
nMem += (int)Vec_IntMemory(&p->vFanin);
nMem += (int)Vec_IntMemory(&p->vIndex);
nMem += (int)Vec_IntMemory(&p->vName);
nMem += (int)Vec_IntMemory(&p->vFanout);
nMem += (int)Vec_IntMemory(&p->vCopy);
nMem += (int)Vec_IntMemory(&p->vOrder);
// stucture
nMem += (int)Vec_StrMemory(&p->vObjType);
nMem += (int)Vec_IntMemory(&p->vObjFin0);
nMem += (int)Vec_IntMemory(&p->vObjFon0);
nMem += (int)Vec_IntMemory(&p->vFinFon);
nMem += (int)Vec_IntMemory(&p->vFonObj);
// optional
nMem += (int)Vec_IntMemory(&p->vObjCopy );
nMem += (int)Vec_IntMemory(&p->vObjFunc );
nMem += (int)Vec_IntMemory(&p->vObjName );
nMem += (int)Vec_IntMemory(&p->vObjAttr );
nMem += (int)Vec_IntMemory(&p->vAttrSto );
nMem += (int)Vec_IntMemory(&p->vFonCopy );
nMem += (int)Vec_IntMemory(&p->vFonName );
nMem += (int)Vec_IntMemory(&p->vFonRange );
nMem += (int)Vec_IntMemory(&p->vFonLeft );
nMem += (int)Vec_IntMemory(&p->vFonRight );
nMem += (int)Vec_IntMemory(&p->vFonPrev );
nMem += (int)Vec_IntMemory(&p->vFonNext );
nMem += (int)Vec_IntMemory(&p->vFinFon0 );
nMem += (int)Vec_IntMemory(&p->vFinObj );
nMem += (int)Vec_IntMemory(&p->vNtkObjs );
// other
nMem += (int)Vec_IntMemory(&p->vArray1 );
nMem += (int)Vec_IntMemory(&p->vArray1 );
return nMem;
}
static inline int Cba_NtkIsTopoOrder( Cba_Ntk_t * p )
{
int i, iObj, iFin, iFanin, fTopo = 1;
Vec_Bit_t * vVisited = Vec_BitStart( Cba_NtkObjNum(p) + 1 );
Cba_NtkForEachObj( p, iObj )
{
Cba_ObjForEachFinFaninReal( p, iObj, iFin, iFanin, i )
if ( !Vec_BitEntry(vVisited, iFanin) )
fTopo = 0;
if ( !fTopo )
break;
Vec_BitWriteEntry( vVisited, iObj, 1 );
}
Vec_BitFree( vVisited );
return fTopo;
}
static inline void Cba_NtkPrintStats( Cba_Ntk_t * p )
{
printf( "pi =%5d ", Cba_NtkPiNum(p) );
printf( "pi =%5d ", Cba_NtkPoNum(p) );
printf( "box =%6d ", Cba_NtkBoxNum(p) );
printf( "clp =%7d ", p->Count );
printf( "obj =%7d ", Cba_NtkObjNum(p) );
printf( "%s ", Cba_NtkName(p) );
if ( Cba_NtkHostNtk(p) > 0 )
printf( "-> %s", Cba_NtkName(Cba_NtkHostNtk(p)) );
printf( "po =%5d ", Cba_NtkPoNum(p) );
printf( "user =%6d ", Cba_NtkBoxUserNum(p) );
printf( "prim =%6d ", Cba_NtkBoxPrimNum(p) );
printf( "topo =%4s ", Cba_NtkIsTopoOrder(p) ? "yes" : "no" );
printf( " %s ", Cba_NtkName(p) );
if ( Vec_IntSize(&p->vNtkObjs) )
printf( "-> %s", Cba_NtkName(Cba_NtkNtk(p, Vec_IntEntry(&p->vNtkObjs, 0))) );
printf( "\n" );
}
static inline void Cba_NtkDeriveIndex( Cba_Ntk_t * p )
{
int i, iObj, iTerm;
Vec_IntFill( &p->vIndex, Cba_NtkObjNum(p), -1 );
Cba_NtkForEachPi( p, iObj, i )
Cba_ObjSetIndex( p, iObj, i );
Cba_NtkForEachPo( p, iObj, i )
Cba_ObjSetIndex( p, iObj, i );
Cba_NtkForEachBox( p, iObj )
{
Cba_BoxForEachBi( p, iObj, iTerm, i )
Cba_ObjSetIndex( p, iTerm, i );
Cba_BoxForEachBo( p, iObj, iTerm, i )
Cba_ObjSetIndex( p, iTerm, i );
}
// Vec_StrIntPrint( &p->vObjType );
}
static inline void Cba_NtkPrint( Cba_Ntk_t * p )
{
int i, Type, Value, Beg, End;
printf( "Interface (%d):\n", Cba_NtkInfoNum(p) );
Vec_IntForEachEntryTriple( &p->vInfo, Value, Beg, End, i )
{
printf( "%6d : ", i );
printf( "Type =%3d ", Cba_NtkInfoType(p, i/3) );
if ( Beg >= 0 )
printf( "[%d:%d] ", End, Beg );
else
printf( " " );
printf( "Name =%3d ", Cba_NtkInfoName(p, i/3) );
if ( Cba_NtkInfoName(p, i/3) )
printf( "%s", Cba_NtkStr( p, Cba_NtkInfoName(p, i/3) ) );
printf( "\n" );
}
int i, Type;
printf( "Interface (%d):\n", Cba_NtkPioNum(p) );
printf( "Objects (%d):\n", Cba_NtkObjNum(p) );
Cba_NtkForEachObjType( p, Type, i )
{
printf( "%6d : ", i );
printf( "Type =%3d ", Type );
if ( Cba_ObjIsCo(p, i) )
printf( "Fanin =%6d ", Cba_ObjFanin(p, i) );
else if ( Cba_NtkHasNames(p) && Cba_ObjName(p, i) )
{
printf( "Name =%6d(%d) ", Cba_ObjNameId(p, i), Cba_ObjNameType(p, i) );
if ( Cba_ObjNameType(p, i) <= CBA_NAME_WORD )
printf( "Fins = %d ", Cba_ObjFinNum(p, i) );
printf( "Fons = %d ", Cba_ObjFonNum(p, i) );
if ( Cba_NtkHasObjNames(p) && Cba_ObjName(p, i) )
printf( "%s", Cba_ObjNameStr(p, i) );
}
printf( "\n" );
}
}
/**Function*************************************************************
Synopsis [Manager APIs.]
......@@ -716,98 +747,63 @@ static inline void Cba_NtkPrint( Cba_Ntk_t * p )
SeeAlso []
***********************************************************************/
static inline Cba_Man_t * Cba_ManAlloc( char * pFileName, int nNtks )
static inline Cba_Man_t * Cba_ManAlloc( char * pFileName, int nNtks, Abc_Nam_t * pStrs, Abc_Nam_t * pMods )
{
extern void Cba_ManSetupTypes( char ** pNames, char ** pSymbs );
Cba_Ntk_t * pNtk; int i;
Cba_Man_t * pNew = ABC_CALLOC( Cba_Man_t, 1 );
pNew->pName = Extra_FileDesignName( pFileName );
pNew->pSpec = Abc_UtilStrsav( pFileName );
pNew->pStrs = Abc_NamStart( 1000, 24 );
pNew->pMods = Abc_NamStart( 1000, 24 );
pNew->iRoot = 1;
pNew->nNtks = nNtks;
pNew->pNtks = ABC_CALLOC( Cba_Ntk_t, pNew->nNtks + 1 );
Cba_ManForEachNtk( pNew, pNtk, i )
pNtk->pDesign = pNew;
Cba_ManSetupTypes( pNew->pPrimNames, pNew->pPrimSymbs );
pNew->pStrs = pStrs ? pStrs : Abc_NamStart( 1000, 24 );
pNew->pMods = pMods ? pMods : Abc_NamStart( 1000, 24 );
Vec_PtrGrow( &pNew->vNtks, nNtks+1 ); Vec_PtrPush( &pNew->vNtks, NULL );
if ( nNtks == 1 ) pNew->iRoot = 1;
return pNew;
}
static inline Cba_Man_t * Cba_ManStart( Cba_Man_t * p, int nNtks )
static inline Cba_Man_t * Cba_ManDup( Cba_Man_t * p, Vec_Int_t*(* pFuncOrder)(Cba_Ntk_t*) )
{
Cba_Ntk_t * pNtk; int i;
Cba_Man_t * pNew = ABC_CALLOC( Cba_Man_t, 1 );
pNew->pName = Abc_UtilStrsav( Cba_ManName(p) );
pNew->pSpec = Abc_UtilStrsav( Cba_ManSpec(p) );
pNew->pStrs = Abc_NamRef( p->pStrs );
pNew->pMods = Abc_NamStart( 1000, 24 );
pNew->iRoot = 1;
pNew->nNtks = nNtks;
pNew->pNtks = ABC_CALLOC( Cba_Ntk_t, nNtks + 1 );
Cba_ManForEachNtk( pNew, pNtk, i )
pNtk->pDesign = pNew;
return pNew;
}
static inline Cba_Man_t * Cba_ManDup( Cba_Man_t * p )
{
Cba_Ntk_t * pNtk, * pHost; int i;
Cba_Man_t * pNew = Cba_ManStart( p, Cba_ManNtkNum(p) );
Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkSetCopy( pNtk, i );
Cba_Ntk_t * pNtk, * pNtkNew; int i;
Cba_Man_t * pNew = Cba_ManAlloc( p->pSpec, Cba_ManNtkNum(p), Abc_NamRef(p->pStrs), Abc_NamRef(p->pMods) );
Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkDup( Cba_NtkCopyNtk(pNew, pNtk), pNtk );
Cba_ManForEachNtk( p, pNtk, i )
if ( (pHost = Cba_NtkHostNtk(pNtk)) )
Cba_NtkSetHost( Cba_NtkCopyNtk(pNew, pNtk), Cba_NtkCopy(pHost), Cba_ObjCopy(pHost, Cba_NtkHostObj(pNtk)) );
return pNew;
}
static inline Cba_Man_t * Cba_ManDupUserBoxes( Cba_Man_t * p )
{
Cba_Ntk_t * pNtk, * pHost; int i;
Cba_Man_t * pNew = Cba_ManStart( p, Cba_ManNtkNum(p) );
Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkSetCopy( pNtk, i );
Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkDupUserBoxes( Cba_NtkCopyNtk(pNew, pNtk), pNtk );
Cba_ManForEachNtk( p, pNtk, i )
if ( (pHost = Cba_NtkHostNtk(pNtk)) )
Cba_NtkSetHost( Cba_NtkCopyNtk(pNew, pNtk), Cba_NtkCopy(pHost), Cba_ObjCopy(pHost, Cba_NtkHostObj(pNtk)) );
{
pNtkNew = Cba_NtkDupOrder( pNew, pNtk, pFuncOrder );
Cba_NtkDupAttrs( pNtkNew, pNtk );
}
// Cba_ManForEachNtk( p, pNtk, i )
// if ( (pHost = Cba_NtkHostNtk(pNtk)) )
// Cba_NtkSetHost( Cba_NtkCopyNtk(pNew, pNtk), Cba_NtkCopy(pHost), Cba_ObjCopy(pHost, Cba_NtkHostObj(pNtk)) );
pNew->iRoot = Cba_ManNtkNum(pNew);
return pNew;
}
static inline void Cba_ManMoveNames( Cba_Man_t * pNew, Cba_Man_t * p )
{
Cba_Ntk_t * pNtk; int i;
Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkMoveNames( Cba_NtkCopyNtk(pNew, pNtk), pNtk );
}
static inline void Cba_ManFree( Cba_Man_t * p )
{
Cba_Ntk_t * pNtk; int i;
Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkFree( pNtk );
Vec_IntErase( &p->vBuf2LeafNtk );
Vec_IntErase( &p->vBuf2LeafObj );
Vec_IntErase( &p->vBuf2RootNtk );
Vec_IntErase( &p->vBuf2RootObj );
ABC_FREE( p->vNtks.pArray );
Abc_NamDeref( p->pStrs );
Abc_NamDeref( p->pMods );
Vec_StrFreeP( &p->vOut );
Vec_StrFreeP( &p->vOut2 );
ABC_FREE( p->pName );
ABC_FREE( p->pSpec );
ABC_FREE( p->pNtks );
ABC_FREE( p );
}
static inline int Cba_ManIsTopOrder( Cba_Man_t * p )
{
Cba_Ntk_t * pNtk; int i;
Cba_ManForEachNtk( p, pNtk, i )
if ( !Cba_NtkIsTopoOrder(pNtk) )
return 0;
return 1;
}
static inline int Cba_ManMemory( Cba_Man_t * p )
{
Cba_Ntk_t * pNtk; int i;
int nMem = sizeof(Cba_Man_t);
if ( p->pName )
nMem += (int)strlen(p->pName);
if ( p->pSpec )
nMem += (int)strlen(p->pSpec);
nMem += p->pName ? (int)strlen(p->pName) : 0;
nMem += p->pSpec ? (int)strlen(p->pSpec) : 0;
nMem += Abc_NamMemUsed(p->pStrs);
nMem += Abc_NamMemUsed(p->pMods);
nMem += (int)Vec_PtrMemory(&p->vNtks);
Cba_ManForEachNtk( p, pNtk, i )
nMem += Cba_NtkMemory( pNtk );
return nMem;
......@@ -819,43 +815,56 @@ static inline int Cba_ManObjNum( Cba_Man_t * p )
Count += Cba_NtkObjNum(pNtk);
return Count;
}
static inline int Cba_ManNodeNum( Cba_Man_t * p )
static inline int Cba_ManBoxNum( Cba_Man_t * p )
{
Cba_Ntk_t * pNtk; int i, Count = 0;
Cba_ManForEachNtk( p, pNtk, i )
Count += Cba_NtkBoxNum( pNtk );
return Count;
}
static inline int Cba_ManBoxNum_rec( Cba_Ntk_t * p )
static inline void Cba_ManBoxNumRec_rec( Cba_Ntk_t * p, int * pCountP, int * pCountU )
{
int iObj, Counter = 0;
if ( p->Count >= 0 )
return p->Count;
Cba_NtkForEachBox( p, iObj )
Counter += Cba_ObjIsBoxUser(p, iObj) ? Cba_ManBoxNum_rec( Cba_BoxNtk(p, iObj) ) : 1;
return (p->Count = Counter);
int iObj, Id = Cba_NtkId(p);
if ( pCountP[Id] >= 0 )
return;
pCountP[Id] = pCountU[Id] = 0;
Cba_NtkForEachObj( p, iObj )
{
if ( Cba_ObjIsBoxUser(p, iObj) )
{
Cba_ManBoxNumRec_rec( Cba_ObjNtk(p, iObj), pCountP, pCountU );
pCountP[Id] += pCountP[Cba_ObjNtkId(p, iObj)];
pCountU[Id] += pCountU[Cba_ObjNtkId(p, iObj)] + 1;
}
else
pCountP[Id] += 1;
}
}
static inline int Cba_ManBoxNum( Cba_Man_t * p )
static inline void Cba_ManBoxNumRec( Cba_Man_t * p, int * pnPrims, int * pnUsers )
{
Cba_Ntk_t * pNtk; int i;
Cba_ManForEachNtk( p, pNtk, i )
pNtk->Count = -1;
return Cba_ManBoxNum_rec( Cba_ManRoot(p) );
Cba_Ntk_t * pNtk = Cba_ManRoot(p);
int * pCountP = ABC_FALLOC( int, Cba_ManNtkNum(p) + 1 );
int * pCountU = ABC_FALLOC( int, Cba_ManNtkNum(p) + 1 );
Cba_ManBoxNumRec_rec( pNtk, pCountP, pCountU );
*pnPrims = pCountP[Cba_NtkId(pNtk)];
*pnUsers = pCountU[Cba_NtkId(pNtk)];
ABC_FREE( pCountP );
ABC_FREE( pCountU );
}
static inline void Cba_ManPrintStats( Cba_Man_t * p, int nModules, int fVerbose )
{
Cba_Ntk_t * pNtk; int i;
Cba_Ntk_t * pNtk; int i, nPrims, nUsers;
Cba_Ntk_t * pRoot = Cba_ManRoot( p );
Cba_ManBoxNumRec( p, &nPrims, &nUsers );
printf( "%-12s : ", Cba_ManName(p) );
printf( "pi =%5d ", Cba_NtkPiNum(pRoot) );
printf( "po =%5d ", Cba_NtkPoNum(pRoot) );
printf( "pri =%4d ", Cba_ManPrimNum(p) );
printf( "mod =%6d ", Cba_ManNtkNum(p) );
printf( "box =%7d ", Cba_ManNodeNum(p) );
printf( "obj =%7d ", Cba_ManObjNum(p) );
printf( "box =%5d ", nPrims + nUsers );
printf( "prim =%5d ", nPrims );
printf( "user =%5d ", nUsers );
printf( "mem =%6.3f MB", 1.0*Cba_ManMemory(p)/(1<<20) );
printf( "\n" );
Cba_ManBoxNum( p );
Cba_ManForEachNtk( p, pNtk, i )
{
if ( i == nModules+1 )
......@@ -867,146 +876,20 @@ static inline void Cba_ManPrintStats( Cba_Man_t * p, int nModules, int fVerbose
/**Function*************************************************************
Synopsis [Other APIs.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline Cba_ObjType_t Ptr_SopToType( char * pSop )
{
if ( !strcmp(pSop, " 0\n") ) return CBA_BOX_CF;
if ( !strcmp(pSop, " 1\n") ) return CBA_BOX_CT;
if ( !strcmp(pSop, "1 1\n") ) return CBA_BOX_BUF;
if ( !strcmp(pSop, "0 1\n") ) return CBA_BOX_INV;
if ( !strcmp(pSop, "11 1\n") ) return CBA_BOX_AND;
if ( !strcmp(pSop, "00 1\n") ) return CBA_BOX_NOR;
if ( !strcmp(pSop, "00 0\n") ) return CBA_BOX_OR;
if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return CBA_BOX_OR;
if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return CBA_BOX_OR;
if ( !strcmp(pSop, "01 1\n10 1\n") ) return CBA_BOX_XOR;
if ( !strcmp(pSop, "10 1\n01 1\n") ) return CBA_BOX_XOR;
if ( !strcmp(pSop, "11 1\n00 1\n") ) return CBA_BOX_XNOR;
if ( !strcmp(pSop, "00 1\n11 1\n") ) return CBA_BOX_XNOR;
if ( !strcmp(pSop, "10 1\n") ) return CBA_BOX_SHARP;
if ( !strcmp(pSop, "01 1\n") ) return CBA_BOX_SHARPL;
assert( 0 );
return CBA_OBJ_NONE;
}
static inline char * Ptr_SopToTypeName( char * pSop )
{
if ( !strcmp(pSop, " 0\n") ) return "CBA_BOX_C0";
if ( !strcmp(pSop, " 1\n") ) return "CBA_BOX_C1";
if ( !strcmp(pSop, "1 1\n") ) return "CBA_BOX_BUF";
if ( !strcmp(pSop, "0 1\n") ) return "CBA_BOX_INV";
if ( !strcmp(pSop, "11 1\n") ) return "CBA_BOX_AND";
if ( !strcmp(pSop, "00 1\n") ) return "CBA_BOX_NOR";
if ( !strcmp(pSop, "00 0\n") ) return "CBA_BOX_OR";
if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return "CBA_BOX_OR";
if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return "CBA_BOX_OR";
if ( !strcmp(pSop, "01 1\n10 1\n") ) return "CBA_BOX_XOR";
if ( !strcmp(pSop, "10 1\n01 1\n") ) return "CBA_BOX_XOR";
if ( !strcmp(pSop, "11 1\n00 1\n") ) return "CBA_BOX_XNOR";
if ( !strcmp(pSop, "00 1\n11 1\n") ) return "CBA_BOX_XNOR";
if ( !strcmp(pSop, "10 1\n") ) return "CBA_BOX_SHARP";
if ( !strcmp(pSop, "01 1\n") ) return "CBA_BOX_SHARPL";
assert( 0 );
return NULL;
}
static inline char * Ptr_TypeToName( Cba_ObjType_t Type )
{
if ( Type == CBA_BOX_CF ) return "const0";
if ( Type == CBA_BOX_CT ) return "const1";
if ( Type == CBA_BOX_CX ) return "constX";
if ( Type == CBA_BOX_CZ ) return "constZ";
if ( Type == CBA_BOX_BUF ) return "buf";
if ( Type == CBA_BOX_INV ) return "not";
if ( Type == CBA_BOX_AND ) return "and";
if ( Type == CBA_BOX_NAND ) return "nand";
if ( Type == CBA_BOX_OR ) return "or";
if ( Type == CBA_BOX_NOR ) return "nor";
if ( Type == CBA_BOX_XOR ) return "xor";
if ( Type == CBA_BOX_XNOR ) return "xnor";
if ( Type == CBA_BOX_MUX ) return "mux";
if ( Type == CBA_BOX_MAJ ) return "maj";
if ( Type == CBA_BOX_SHARP ) return "sharp";
if ( Type == CBA_BOX_SHARPL) return "sharpl";
assert( 0 );
return "???";
}
static inline char * Ptr_TypeToSop( Cba_ObjType_t Type )
{
if ( Type == CBA_BOX_CF ) return " 0\n";
if ( Type == CBA_BOX_CT ) return " 1\n";
if ( Type == CBA_BOX_CX ) return " 0\n";
if ( Type == CBA_BOX_CZ ) return " 0\n";
if ( Type == CBA_BOX_BUF ) return "1 1\n";
if ( Type == CBA_BOX_INV ) return "0 1\n";
if ( Type == CBA_BOX_AND ) return "11 1\n";
if ( Type == CBA_BOX_NAND ) return "11 0\n";
if ( Type == CBA_BOX_OR ) return "00 0\n";
if ( Type == CBA_BOX_NOR ) return "00 1\n";
if ( Type == CBA_BOX_XOR ) return "01 1\n10 1\n";
if ( Type == CBA_BOX_XNOR ) return "00 1\n11 1\n";
if ( Type == CBA_BOX_SHARP ) return "10 1\n";
if ( Type == CBA_BOX_SHARPL) return "01 1\n";
if ( Type == CBA_BOX_MUX ) return "11- 1\n0-1 1\n";
if ( Type == CBA_BOX_MAJ ) return "11- 1\n1-1 1\n-11 1\n";
assert( 0 );
return "???";
}
/*=== cbaCom.c ===============================================================*/
extern void Abc_FrameImportPtr( Vec_Ptr_t * vPtr );
extern Vec_Ptr_t * Abc_FrameExportPtr();
/*=== cbaBlast.c =============================================================*/
extern int Cba_NtkBuildLibrary( Cba_Man_t * p );
extern Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose );
extern Cba_Man_t * Cba_ManInsertGia( Cba_Man_t * p, Gia_Man_t * pGia );
extern void * Cba_ManInsertAbc( Cba_Man_t * p, void * pAbc );
/*=== cbaCba.c ===============================================================*/
extern Cba_Man_t * Cba_ManReadCba( char * pFileName );
extern void Cba_ManWriteCba( char * pFileName, Cba_Man_t * p );
/*=== cbaCom.c ===============================================================*/
/*=== cbaNtk.c ===============================================================*/
extern char * Cba_NtkGenerateName( Cba_Ntk_t * p, Cba_ObjType_t Type, Vec_Int_t * vBits );
extern Cba_ObjType_t Cba_NameToType( char * pName );
extern Vec_Int_t * Cba_NameToRanges( char * pName );
extern void Cba_NtkUpdateFanout( Cba_Ntk_t * p, int iOld, int iNew );
extern void Cba_ManDeriveFanout( Cba_Man_t * p );
//extern void Cba_ManAssignInternNames( Cba_Man_t * p );
extern void Cba_ManAssignInternWordNames( Cba_Man_t * p );
extern Cba_Man_t * Cba_ManCollapse( Cba_Man_t * p );
extern void Cba_ManSetupTypes( char ** pNames, char ** pSymbs );
/*=== cbaPtr.c ===============================================================*/
extern void Cba_PtrFree( Vec_Ptr_t * vDes );
extern int Cba_PtrMemory( Vec_Ptr_t * vDes );
extern void Cba_PtrDumpBlif( char * pFileName, Vec_Ptr_t * vDes );
extern void Cba_PtrDumpVerilog( char * pFileName, Vec_Ptr_t * vDes );
extern Vec_Ptr_t * Cba_PtrTransformTest( Vec_Ptr_t * vDes );
/*=== cbaPtrAbc.c ============================================================*/
extern Cba_Man_t * Cba_PtrTransformToCba( Vec_Ptr_t * vDes );
extern Vec_Ptr_t * Cba_PtrDeriveFromCba( Cba_Man_t * p );
/*=== cbaPrsBuild.c ==========================================================*/
extern void Prs_ManVecFree( Vec_Ptr_t * vPrs );
extern Cba_Man_t * Prs_ManBuildCba( char * pFileName, Vec_Ptr_t * vDes );
/*=== cbaReadBlif.c ==========================================================*/
extern Vec_Ptr_t * Prs_ManReadBlif( char * pFileName );
/*=== cbaReadSmt.c ===========================================================*/
extern Vec_Ptr_t * Prs_ManReadSmt( char * pFileName );
/*=== cbaReadVer.c ===========================================================*/
extern Vec_Ptr_t * Prs_ManReadVerilog( char * pFileName );
/*=== cbaWriteBlif.c =========================================================*/
extern void Prs_ManWriteBlif( char * pFileName, Vec_Ptr_t * p );
extern void Cba_ManWriteBlif( char * pFileName, Cba_Man_t * p );
//extern void Prs_ManWriteBlif( char * pFileName, Vec_Ptr_t * p );
//extern void Cba_ManWriteBlif( char * pFileName, Cba_Man_t * p );
/*=== cbaWriteVer.c ==========================================================*/
extern void Prs_ManWriteVerilog( char * pFileName, Vec_Ptr_t * p );
extern void Cba_ManWriteVerilog( char * pFileName, Cba_Man_t * p, int fUseAssign );
//extern void Prs_ManWriteVerilog( char * pFileName, Vec_Ptr_t * p );
//extern void Cba_ManWriteVerilog( char * pFileName, Cba_Man_t * p, int fUseAssign );
ABC_NAMESPACE_HEADER_END
......
src/base/cba/cbaBlast.c
/**CFile****************************************************************
FileName [cbaBlast.c]
FileName [cba.c]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Hierarchical word-level netlist.]
PackageName [Verilog parser.]
Synopsis [Bit-blasting of the netlist.]
Synopsis [Parses several flavors of word-level Verilog.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - November 29, 2014.]
Date [Ver. 1.0. Started - July 21, 2015.]
Revision [$Id: cbaBlast.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
Revision [$Id: cba.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
***********************************************************************/
#include "cba.h"
#include "base/abc/abc.h"
#include "map/mio/mio.h"
#include "bool/dec/dec.h"
#include "base/main/mainInt.h"
ABC_NAMESPACE_IMPL_START
......@@ -45,539 +41,8 @@ ABC_NAMESPACE_IMPL_START
SeeAlso []
***********************************************************************/
void Cba_ManPrepareGates( Cba_Man_t * p )
{
Dec_Graph_t ** ppGraphs; int i;
if ( p->pMioLib == NULL )
return;
ppGraphs = ABC_CALLOC( Dec_Graph_t *, Abc_NamObjNumMax(p->pMods) );
for ( i = 1; i < Abc_NamObjNumMax(p->pMods); i++ )
{
char * pGateName = Abc_NamStr( p->pMods, i );
Mio_Gate_t * pGate = Mio_LibraryReadGateByName( (Mio_Library_t *)p->pMioLib, pGateName, NULL );
if ( pGate != NULL )
ppGraphs[i] = Dec_Factor( Mio_GateReadSop(pGate) );
}
assert( p->ppGraphs == NULL );
p->ppGraphs = (void **)ppGraphs;
}
void Cba_ManUndoGates( Cba_Man_t * p )
{
int i;
if ( p->pMioLib == NULL )
return;
for ( i = 1; i < Abc_NamObjNumMax(p->pMods); i++ )
if ( p->ppGraphs[i] )
Dec_GraphFree( (Dec_Graph_t *)p->ppGraphs[i] );
ABC_FREE( p->ppGraphs );
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Cba_ManAddBarbuf( Gia_Man_t * pNew, int iRes, Cba_Man_t * p, int iLNtk, int iLObj, int iRNtk, int iRObj, Vec_Int_t * vMap )
{
int iBufLit, iIdLit;
if ( iRes == 0 || iRes == 1 )
return iRes;
assert( iRes > 0 );
if ( vMap && Abc_Lit2Var(iRes) < Vec_IntSize(vMap) && (iIdLit = Vec_IntEntry(vMap, Abc_Lit2Var(iRes))) >= 0 &&
Vec_IntEntry(&p->vBuf2LeafNtk, Abc_Lit2Var(iIdLit)) == iLNtk && Vec_IntEntry(&p->vBuf2RootNtk, Abc_Lit2Var(iIdLit)) == iRNtk )
return Abc_LitNotCond( Vec_IntEntry(pNew->vBarBufs, Abc_Lit2Var(iIdLit)), Abc_LitIsCompl(iRes) ^ Abc_LitIsCompl(iIdLit) );
assert( Cba_ManNtkIsOk(p, iLNtk) && Cba_ManNtkIsOk(p, iRNtk) );
Vec_IntPush( &p->vBuf2LeafNtk, iLNtk );
Vec_IntPush( &p->vBuf2LeafObj, iLObj );
Vec_IntPush( &p->vBuf2RootNtk, iRNtk );
Vec_IntPush( &p->vBuf2RootObj, iRObj );
iBufLit = Gia_ManAppendBuf( pNew, iRes );
if ( vMap )
{
Vec_IntSetEntryFull( vMap, Abc_Lit2Var(iRes), Abc_Var2Lit(Vec_IntSize(pNew->vBarBufs), Abc_LitIsCompl(iRes)) );
Vec_IntPush( pNew->vBarBufs, iBufLit );
}
return iBufLit;
}
int Cba_ManExtract_rec( Gia_Man_t * pNew, Cba_Ntk_t * p, int i, int fBuffers, Vec_Int_t * vMap )
{
int iRes = Cba_ObjCopy( p, i );
if ( iRes >= 0 )
return iRes;
if ( Cba_ObjIsCo(p, i) )
iRes = Cba_ManExtract_rec( pNew, p, Cba_ObjFanin(p, i), fBuffers, vMap );
else if ( Cba_ObjIsPi(p, i) )
{
Cba_Ntk_t * pHost = Cba_NtkHostNtk( p );
int iObj = Cba_BoxBi( pHost, Cba_NtkHostObj(p), Cba_ObjIndex(p, i) );
iRes = Cba_ManExtract_rec( pNew, pHost, iObj, fBuffers, vMap );
if ( fBuffers )
iRes = Cba_ManAddBarbuf( pNew, iRes, p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pHost), iObj, vMap );
}
else if ( Cba_ObjIsBo(p, i) )
{
int iBox = Cba_BoxBoBox(p, i);
if ( Cba_ObjIsBoxUser(p, iBox) ) // user box
{
Cba_Ntk_t * pBox = Cba_BoxBoNtk( p, i );
int iObj = Cba_NtkPo( pBox, Cba_ObjIndex(p, i) );
iRes = Cba_ManExtract_rec( pNew, pBox, iObj, fBuffers, vMap );
if ( fBuffers )
iRes = Cba_ManAddBarbuf( pNew, iRes, p->pDesign, Cba_NtkId(p), i, Cba_NtkId(pBox), iObj, vMap );
}
else // primitive
{
int iFanin, nLits, pLits[16];
assert( Cba_ObjIsBoxPrim(p, iBox) );
Cba_BoxForEachFanin( p, iBox, iFanin, nLits )
pLits[nLits] = Cba_ManExtract_rec( pNew, p, iFanin, fBuffers, vMap );
assert( nLits <= 16 );
if ( p->pDesign->ppGraphs ) // mapped gate
{
extern int Gia_ManFactorGraph( Gia_Man_t * p, Dec_Graph_t * pFForm, Vec_Int_t * vLeaves );
Dec_Graph_t * pGraph = (Dec_Graph_t *)p->pDesign->ppGraphs[Cba_BoxNtkId(p, iBox)];
Vec_Int_t Leaves = { nLits, nLits, pLits };
assert( pGraph != NULL );
return Gia_ManFactorGraph( pNew, pGraph, &Leaves );
}
else
{
Cba_ObjType_t Type = Cba_ObjType(p, iBox);
if ( nLits == 0 )
{
if ( Type == CBA_BOX_CF )
iRes = 0;
else if ( Type == CBA_BOX_CT )
iRes = 1;
else assert( 0 );
}
else if ( nLits == 1 )
{
if ( Type == CBA_BOX_BUF )
iRes = pLits[0];
else if ( Type == CBA_BOX_INV )
iRes = Abc_LitNot( pLits[0] );
else assert( 0 );
}
else if ( nLits == 2 )
{
if ( Type == CBA_BOX_AND )
iRes = Gia_ManHashAnd( pNew, pLits[0], pLits[1] );
else if ( Type == CBA_BOX_NAND )
iRes = Abc_LitNot( Gia_ManHashAnd( pNew, pLits[0], pLits[1] ) );
else if ( Type == CBA_BOX_OR )
iRes = Gia_ManHashOr( pNew, pLits[0], pLits[1] );
else if ( Type == CBA_BOX_NOR )
iRes = Abc_LitNot( Gia_ManHashOr( pNew, pLits[0], pLits[1] ) );
else if ( Type == CBA_BOX_XOR )
iRes = Gia_ManHashXor( pNew, pLits[0], pLits[1] );
else if ( Type == CBA_BOX_XNOR )
iRes = Abc_LitNot( Gia_ManHashXor( pNew, pLits[0], pLits[1] ) );
else if ( Type == CBA_BOX_SHARP )
iRes = Gia_ManHashAnd( pNew, pLits[0], Abc_LitNot(pLits[1]) );
else if ( Type == CBA_BOX_SHARPL )
iRes = Gia_ManHashAnd( pNew, Abc_LitNot(pLits[0]), pLits[1] );
else assert( 0 );
}
else if ( nLits == 3 )
{
if ( Type == CBA_BOX_MUX )
iRes = Gia_ManHashMux( pNew, pLits[0], pLits[1], pLits[2] );
else if ( Type == CBA_BOX_MAJ )
iRes = Gia_ManHashMaj( pNew, pLits[0], pLits[1], pLits[2] );
else if ( Type == CBA_BOX_ADD )
{
int iRes0 = Gia_ManHashAnd( pNew, pLits[1], pLits[2] );
int iRes1 = Gia_ManHashOr( pNew, pLits[1], pLits[2] );
assert( Cba_BoxBoNum(p, iBox) == 2 );
if ( Cba_BoxBo(p, iBox, 0) == i ) // sum
iRes = Gia_ManHashXor( pNew, pLits[0], Gia_ManHashAnd(pNew, Abc_LitNot(iRes0), iRes1) );
else if ( Cba_BoxBo(p, iBox, 1) == i ) // cout
iRes = Gia_ManHashOr( pNew, iRes0, Gia_ManHashAnd(pNew, pLits[0], iRes1) );
else assert( 0 );
}
else assert( 0 );
}
else assert( 0 );
}
}
}
else assert( 0 );
Cba_ObjSetCopy( p, i, iRes );
return iRes;
}
Gia_Man_t * Cba_ManExtract( Cba_Man_t * p, int fBuffers, int fVerbose )
{
Cba_Ntk_t * pNtk, * pRoot = Cba_ManRoot(p);
Gia_Man_t * pNew, * pTemp;
Vec_Int_t * vMap = NULL;
int i, iObj;
Vec_IntClear( &p->vBuf2LeafNtk );
Vec_IntClear( &p->vBuf2LeafObj );
Vec_IntClear( &p->vBuf2RootNtk );
Vec_IntClear( &p->vBuf2RootObj );
Cba_ManForEachNtk( p, pNtk, i )
{
Cba_NtkDeriveIndex( pNtk );
Cba_NtkStartCopies( pNtk );
}
// start the manager
pNew = Gia_ManStart( Cba_ManNodeNum(p) );
pNew->pName = Abc_UtilStrsav(p->pName);
pNew->pSpec = Abc_UtilStrsav(p->pSpec);
// primary inputs
Cba_NtkForEachPi( pRoot, iObj, i )
Cba_ObjSetCopy( pRoot, iObj, Gia_ManAppendCi(pNew) );
// internal nodes
Gia_ManHashAlloc( pNew );
pNew->vBarBufs = Vec_IntAlloc( 10000 );
vMap = Vec_IntStartFull( 10000 );
Cba_ManPrepareGates( p );
Cba_NtkForEachPo( pRoot, iObj, i )
Cba_ManExtract_rec( pNew, pRoot, iObj, fBuffers, vMap );
Cba_ManUndoGates( p );
Vec_IntFreeP( &vMap );
Gia_ManHashStop( pNew );
// primary outputs
Cba_NtkForEachPo( pRoot, iObj, i )
Gia_ManAppendCo( pNew, Cba_ObjCopy(pRoot, iObj) );
assert( Vec_IntSize(&p->vBuf2LeafNtk) == pNew->nBufs );
// cleanup
pNew = Gia_ManCleanup( pTemp = pNew );
Gia_ManStop( pTemp );
//Gia_ManPrintStats( pNew, NULL );
return pNew;
}
/**Function*************************************************************
Synopsis [Mark each GIA node with the network it belongs to.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Cba_ManMarkNodesGia( Cba_Man_t * p, Gia_Man_t * pGia )
{
Gia_Obj_t * pObj; int i, Count = 0;
assert( Vec_IntSize(&p->vBuf2LeafNtk) == Gia_ManBufNum(pGia) );
Gia_ManConst0(pGia)->Value = 1;
Gia_ManForEachPi( pGia, pObj, i )
pObj->Value = 1;
Gia_ManForEachAnd( pGia, pObj, i )
{
if ( Gia_ObjIsBuf(pObj) )
pObj->Value = Vec_IntEntry( &p->vBuf2LeafNtk, Count++ );
else
{
pObj->Value = Gia_ObjFanin0(pObj)->Value;
assert( pObj->Value == Gia_ObjFanin1(pObj)->Value );
}
}
assert( Count == Gia_ManBufNum(pGia) );
Gia_ManForEachPo( pGia, pObj, i )
{
assert( Gia_ObjFanin0(pObj)->Value == 1 );
pObj->Value = 1;
}
}
void Cba_ManRemapBarbufs( Cba_Man_t * pNew, Cba_Man_t * p )
{
Cba_Ntk_t * pNtk; int Entry, i;
//assert( Vec_IntSize(&p->vBuf2RootNtk) );
assert( !Vec_IntSize(&pNew->vBuf2RootNtk) );
Vec_IntAppend( &pNew->vBuf2RootNtk, &p->vBuf2RootNtk );
Vec_IntAppend( &pNew->vBuf2RootObj, &p->vBuf2RootObj );
Vec_IntAppend( &pNew->vBuf2LeafNtk, &p->vBuf2LeafNtk );
Vec_IntAppend( &pNew->vBuf2LeafObj, &p->vBuf2LeafObj );
Vec_IntForEachEntry( &p->vBuf2LeafObj, Entry, i )
{
pNtk = Cba_ManNtk( p, Vec_IntEntry(&p->vBuf2LeafNtk, i) );
Vec_IntWriteEntry( &pNew->vBuf2LeafObj, i, Cba_ObjCopy(pNtk, Entry) );
}
Vec_IntForEachEntry( &p->vBuf2RootObj, Entry, i )
{
pNtk = Cba_ManNtk( p, Vec_IntEntry(&p->vBuf2RootNtk, i) );
Vec_IntWriteEntry( &pNew->vBuf2RootObj, i, Cba_ObjCopy(pNtk, Entry) );
}
}
void Cba_NtkCreateAndConnectBuffer( Gia_Man_t * pGia, Gia_Obj_t * pObj, Cba_Ntk_t * p, int iTerm )
{
int iObj;
if ( pGia && Gia_ObjFaninId0p(pGia, pObj) > 0 )
{
iObj = Cba_ObjAlloc( p, CBA_OBJ_BI, Gia_ObjFanin0(pObj)->Value );
Cba_ObjAlloc( p, Gia_ObjFaninC0(pObj) ? CBA_BOX_INV : CBA_BOX_BUF, -1 );
}
else
{
Cba_ObjAlloc( p, pGia && Gia_ObjFaninC0(pObj) ? CBA_BOX_CT : CBA_BOX_CF, -1 );
}
iObj = Cba_ObjAlloc( p, CBA_OBJ_BO, -1 );
Cba_ObjSetFanin( p, iTerm, iObj );
}
void Cba_NtkInsertGia( Cba_Man_t * p, Gia_Man_t * pGia )
{
Cba_Ntk_t * pNtk, * pRoot = Cba_ManRoot( p );
int i, j, k, iBox, iTerm, Count = 0;
Gia_Obj_t * pObj;
Gia_ManConst0(pGia)->Value = ~0;
Gia_ManForEachPi( pGia, pObj, i )
pObj->Value = Cba_NtkPi( pRoot, i );
Gia_ManForEachAnd( pGia, pObj, i )
{
if ( Gia_ObjIsBuf(pObj) )
{
pNtk = Cba_ManNtk( p, Vec_IntEntry(&p->vBuf2RootNtk, Count) );
iTerm = Vec_IntEntry( &p->vBuf2RootObj, Count );
assert( Cba_ObjIsCo(pNtk, iTerm) );
if ( Cba_ObjFanin(pNtk, iTerm) == -1 ) // not a feedthrough
Cba_NtkCreateAndConnectBuffer( pGia, pObj, pNtk, iTerm );
// prepare leaf
pObj->Value = Vec_IntEntry( &p->vBuf2LeafObj, Count++ );
}
else
{
int iLit0 = Gia_ObjFanin0(pObj)->Value;
int iLit1 = Gia_ObjFanin1(pObj)->Value;
Cba_ObjType_t Type;
pNtk = Cba_ManNtk( p, pObj->Value );
if ( Gia_ObjFaninC0(pObj) && Gia_ObjFaninC1(pObj) )
Type = CBA_BOX_NOR;
else if ( Gia_ObjFaninC1(pObj) )
Type = CBA_BOX_SHARP;
else if ( Gia_ObjFaninC0(pObj) )
{
Type = CBA_BOX_SHARP;
ABC_SWAP( int, iLit0, iLit1 );
}
else
Type = CBA_BOX_AND;
// create box
iTerm = Cba_ObjAlloc( pNtk, CBA_OBJ_BI, iLit1 );
iTerm = Cba_ObjAlloc( pNtk, CBA_OBJ_BI, iLit0 );
Cba_ObjAlloc( pNtk, Type, -1 );
pObj->Value = Cba_ObjAlloc( pNtk, CBA_OBJ_BO, -1 );
}
}
assert( Count == Gia_ManBufNum(pGia) );
// create constant 0 drivers for COs without barbufs
Cba_ManForEachNtk( p, pNtk, i )
{
Cba_NtkForEachBox( pNtk, iBox )
Cba_BoxForEachBi( pNtk, iBox, iTerm, j )
if ( Cba_ObjFanin(pNtk, iTerm) == -1 )
Cba_NtkCreateAndConnectBuffer( NULL, NULL, pNtk, iTerm );
Cba_NtkForEachPo( pNtk, iTerm, k )
if ( pNtk != pRoot && Cba_ObjFanin(pNtk, iTerm) == -1 )
Cba_NtkCreateAndConnectBuffer( NULL, NULL, pNtk, iTerm );
}
// create node and connect POs
Gia_ManForEachPo( pGia, pObj, i )
if ( Cba_ObjFanin(pRoot, Cba_NtkPo(pRoot, i)) == -1 ) // not a feedthrough
Cba_NtkCreateAndConnectBuffer( pGia, pObj, pRoot, Cba_NtkPo(pRoot, i) );
}
Cba_Man_t * Cba_ManInsertGia( Cba_Man_t * p, Gia_Man_t * pGia )
{
Cba_Man_t * pNew = Cba_ManDupUserBoxes( p );
Cba_ManMarkNodesGia( p, pGia );
Cba_ManRemapBarbufs( pNew, p );
Cba_NtkInsertGia( pNew, pGia );
Cba_ManMoveNames( pNew, p );
return pNew;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Cba_Man_t * Cba_ManBlastTest( Cba_Man_t * p )
{
Gia_Man_t * pGia = Cba_ManExtract( p, 1, 0 );
Cba_Man_t * pNew = Cba_ManInsertGia( p, pGia );
Gia_ManStop( pGia );
return pNew;
}
/**Function*************************************************************
Synopsis [Mark each GIA node with the network it belongs to.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline int Abc_NodeIsSeriousGate( Abc_Obj_t * p )
{
return Abc_ObjIsNode(p) && Abc_ObjFaninNum(p) > 0 && !Abc_ObjIsBarBuf(p);
}
void Cba_ManMarkNodesAbc( Cba_Man_t * p, Abc_Ntk_t * pNtk )
{
Abc_Obj_t * pObj, * pFanin; int i, k, Count = 0;
assert( Vec_IntSize(&p->vBuf2LeafNtk) == pNtk->nBarBufs2 );
Abc_NtkForEachPi( pNtk, pObj, i )
pObj->iTemp = 1;
Abc_NtkForEachNode( pNtk, pObj, i )
{
if ( Abc_ObjIsBarBuf(pObj) )
pObj->iTemp = Vec_IntEntry( &p->vBuf2LeafNtk, Count++ );
else if ( Abc_NodeIsSeriousGate(pObj) )
{
pObj->iTemp = Abc_ObjFanin0(pObj)->iTemp;
Abc_ObjForEachFanin( pObj, pFanin, k )
assert( pObj->iTemp == pFanin->iTemp );
}
}
Abc_NtkForEachPo( pNtk, pObj, i )
{
if ( !Abc_NodeIsSeriousGate(Abc_ObjFanin0(pObj)) )
continue;
assert( Abc_ObjFanin0(pObj)->iTemp == 1 );
pObj->iTemp = Abc_ObjFanin0(pObj)->iTemp;
}
assert( Count == pNtk->nBarBufs2 );
}
void Cba_NtkCreateOrConnectFanin( Abc_Obj_t * pFanin, Cba_Ntk_t * p, int iTerm )
{
int iObj;
if ( pFanin && Abc_NodeIsSeriousGate(pFanin) )//&& Cba_ObjName(p, pFanin->iTemp) == -1 ) // gate without name
{
iObj = pFanin->iTemp;
}
else if ( pFanin && (Abc_ObjIsPi(pFanin) || Abc_ObjIsBarBuf(pFanin) || Abc_NodeIsSeriousGate(pFanin)) ) // PI/BO or gate with name
{
iObj = Cba_ObjAlloc( p, CBA_OBJ_BI, pFanin->iTemp );
Cba_ObjAlloc( p, CBA_BOX_GATE, p->pDesign->ElemGates[2] ); // buffer
iObj = Cba_ObjAlloc( p, CBA_OBJ_BO, -1 );
}
else
{
assert( !pFanin || Abc_NodeIsConst0(pFanin) || Abc_NodeIsConst1(pFanin) );
Cba_ObjAlloc( p, CBA_BOX_GATE, p->pDesign->ElemGates[(pFanin && Abc_NodeIsConst1(pFanin))] ); // const 0/1
iObj = Cba_ObjAlloc( p, CBA_OBJ_BO, -1 );
}
Cba_ObjSetFanin( p, iTerm, iObj );
}
void Cba_NtkPrepareLibrary( Cba_Man_t * p, Mio_Library_t * pLib )
{
Mio_Gate_t * pGate;
Mio_Gate_t * pGate0 = Mio_LibraryReadConst0( pLib );
Mio_Gate_t * pGate1 = Mio_LibraryReadConst1( pLib );
Mio_Gate_t * pGate2 = Mio_LibraryReadBuf( pLib );
if ( !pGate0 || !pGate1 || !pGate2 )
{
printf( "The library does not have one of the elementary gates.\n" );
return;
}
p->ElemGates[0] = Abc_NamStrFindOrAdd( p->pMods, Mio_GateReadName(pGate0), NULL );
p->ElemGates[1] = Abc_NamStrFindOrAdd( p->pMods, Mio_GateReadName(pGate1), NULL );
p->ElemGates[2] = Abc_NamStrFindOrAdd( p->pMods, Mio_GateReadName(pGate2), NULL );
Mio_LibraryForEachGate( pLib, pGate )
if ( pGate != pGate0 && pGate != pGate1 && pGate != pGate2 )
Abc_NamStrFindOrAdd( p->pMods, Mio_GateReadName(pGate), NULL );
assert( Abc_NamObjNumMax(p->pMods) > 1 );
}
int Cba_NtkBuildLibrary( Cba_Man_t * p )
{
int RetValue = 1;
Mio_Library_t * pLib = (Mio_Library_t *)Abc_FrameReadLibGen();
if ( pLib == NULL )
printf( "The standard cell library is not available.\n" ), RetValue = 0;
else
Cba_NtkPrepareLibrary( p, pLib );
p->pMioLib = pLib;
return RetValue;
}
void Cba_NtkInsertNtk( Cba_Man_t * p, Abc_Ntk_t * pNtk )
{
Cba_Ntk_t * pCbaNtk, * pRoot = Cba_ManRoot( p );
int i, j, k, iBox, iTerm, Count = 0;
Abc_Obj_t * pObj;
assert( Abc_NtkHasMapping(pNtk) );
Cba_NtkPrepareLibrary( p, (Mio_Library_t *)pNtk->pManFunc );
p->pMioLib = pNtk->pManFunc;
Abc_NtkForEachPi( pNtk, pObj, i )
pObj->iTemp = Cba_NtkPi( pRoot, i );
Abc_NtkForEachNode( pNtk, pObj, i )
{
if ( Abc_ObjIsBarBuf(pObj) )
{
pCbaNtk = Cba_ManNtk( p, Vec_IntEntry(&p->vBuf2RootNtk, Count) );
iTerm = Vec_IntEntry( &p->vBuf2RootObj, Count );
assert( Cba_ObjIsCo(pCbaNtk, iTerm) );
if ( Cba_ObjFanin(pCbaNtk, iTerm) == -1 ) // not a feedthrough
Cba_NtkCreateOrConnectFanin( Abc_ObjFanin0(pObj), pCbaNtk, iTerm );
// prepare leaf
pObj->iTemp = Vec_IntEntry( &p->vBuf2LeafObj, Count++ );
}
else if ( Abc_NodeIsSeriousGate(pObj) )
{
pCbaNtk = Cba_ManNtk( p, pObj->iTemp );
for ( k = Abc_ObjFaninNum(pObj)-1; k >= 0; k-- )
iTerm = Cba_ObjAlloc( pCbaNtk, CBA_OBJ_BI, Abc_ObjFanin(pObj, k)->iTemp );
Cba_ObjAlloc( pCbaNtk, CBA_BOX_GATE, Abc_NamStrFind(p->pMods, Mio_GateReadName((Mio_Gate_t *)pObj->pData)) );
pObj->iTemp = Cba_ObjAlloc( pCbaNtk, CBA_OBJ_BO, -1 );
}
}
assert( Count == pNtk->nBarBufs2 );
// create constant 0 drivers for COs without barbufs
Cba_ManForEachNtk( p, pCbaNtk, i )
{
Cba_NtkForEachBox( pCbaNtk, iBox )
Cba_BoxForEachBi( pCbaNtk, iBox, iTerm, j )
if ( Cba_ObjFanin(pCbaNtk, iTerm) == -1 )
Cba_NtkCreateOrConnectFanin( NULL, pCbaNtk, iTerm );
Cba_NtkForEachPo( pCbaNtk, iTerm, k )
if ( pCbaNtk != pRoot && Cba_ObjFanin(pCbaNtk, iTerm) == -1 )
Cba_NtkCreateOrConnectFanin( NULL, pCbaNtk, iTerm );
}
// create node and connect POs
Abc_NtkForEachPo( pNtk, pObj, i )
if ( Cba_ObjFanin(pRoot, Cba_NtkPo(pRoot, i)) == -1 ) // not a feedthrough
Cba_NtkCreateOrConnectFanin( Abc_ObjFanin0(pObj), pRoot, Cba_NtkPo(pRoot, i) );
}
void * Cba_ManInsertAbc( Cba_Man_t * p, void * pAbc )
{
Abc_Ntk_t * pNtk = (Abc_Ntk_t *)pAbc;
Cba_Man_t * pNew = Cba_ManDupUserBoxes( p );
Cba_ManMarkNodesAbc( p, pNtk );
Cba_ManRemapBarbufs( pNew, p );
Cba_NtkInsertNtk( pNew, pNtk );
Cba_ManMoveNames( pNew, p );
return pNew;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
......
src/base/cba/cbaCba.c
/**CFile****************************************************************
FileName [cbaCba.c]
FileName [cba.c]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Hierarchical word-level netlist.]
PackageName [Verilog parser.]
Synopsis [Verilog parser.]
Synopsis [Parses several flavors of word-level Verilog.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - November 29, 2014.]
Date [Ver. 1.0. Started - July 21, 2015.]
Revision [$Id: cbaCba.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
Revision [$Id: cba.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
***********************************************************************/
......@@ -30,10 +30,9 @@ ABC_NAMESPACE_IMPL_START
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Read CBA.]
Synopsis []
Description []
......@@ -42,252 +41,7 @@ ABC_NAMESPACE_IMPL_START
SeeAlso []
***********************************************************************/
int CbaManReadCbaLine( Vec_Str_t * vOut, int * pPos, char * pBuffer, char * pLimit )
{
char c;
while ( (c = Vec_StrEntry(vOut, (*pPos)++)) != '\n' && pBuffer < pLimit )
*pBuffer++ = c;
*pBuffer = 0;
return pBuffer < pLimit;
}
int CbaManReadCbaNameAndNums( char * pBuffer, int * Num1, int * Num2, int * Num3, int * Num4 )
{
*Num1 = *Num2 = *Num3 = *Num4 = -1;
// read name
while ( *pBuffer && *pBuffer != ' ' )
pBuffer++;
if ( !*pBuffer )
return 0;
assert( *pBuffer == ' ' );
*pBuffer = 0;
// read Num1
*Num1 = atoi(++pBuffer);
while ( *pBuffer && *pBuffer != ' ' )
pBuffer++;
if ( !*pBuffer )
return 0;
// read Num2
assert( *pBuffer == ' ' );
*Num2 = atoi(++pBuffer);
while ( *pBuffer && *pBuffer != ' ' )
pBuffer++;
if ( !*pBuffer )
return 1;
// read Num3
assert( *pBuffer == ' ' );
*Num3 = atoi(++pBuffer);
while ( *pBuffer && *pBuffer != ' ' )
pBuffer++;
if ( !*pBuffer )
return 1;
// read Num4
assert( *pBuffer == ' ' );
*Num4 = atoi(++pBuffer);
return 1;
}
void Cba_ManReadCbaVecStr( Vec_Str_t * vOut, int * pPos, Vec_Str_t * p, int nSize )
{
memcpy( Vec_StrArray(p), Vec_StrArray(vOut) + *pPos, nSize );
*pPos += nSize;
p->nSize = nSize;
assert( Vec_StrSize(p) == Vec_StrCap(p) );
}
void Cba_ManReadCbaVecInt( Vec_Str_t * vOut, int * pPos, Vec_Int_t * p, int nSize )
{
memcpy( Vec_IntArray(p), Vec_StrArray(vOut) + *pPos, nSize );
*pPos += nSize;
p->nSize = nSize / 4;
assert( Vec_IntSize(p) == Vec_IntCap(p) );
}
void Cba_ManReadCbaNtk( Vec_Str_t * vOut, int * pPos, Cba_Ntk_t * pNtk )
{
int i, Type;
//char * pName; int iObj, NameId;
Cba_ManReadCbaVecStr( vOut, pPos, &pNtk->vType, Cba_NtkObjNumAlloc(pNtk) );
Cba_ManReadCbaVecInt( vOut, pPos, &pNtk->vFanin, 4 * Cba_NtkObjNumAlloc(pNtk) );
Cba_ManReadCbaVecInt( vOut, pPos, &pNtk->vInfo, 12 * Cba_NtkInfoNumAlloc(pNtk) );
Cba_NtkForEachObjType( pNtk, Type, i )
{
if ( Type == CBA_OBJ_PI )
Vec_IntPush( &pNtk->vInputs, i );
if ( Type == CBA_OBJ_PO )
Vec_IntPush( &pNtk->vOutputs, i );
}
assert( Cba_NtkPiNum(pNtk) == Cba_NtkPiNumAlloc(pNtk) );
assert( Cba_NtkPoNum(pNtk) == Cba_NtkPoNumAlloc(pNtk) );
assert( Cba_NtkObjNum(pNtk) == Cba_NtkObjNumAlloc(pNtk) );
assert( Cba_NtkInfoNum(pNtk) == Cba_NtkInfoNumAlloc(pNtk) );
/*
// read input/output/box names
Cba_NtkForEachPiMain( pNtk, iObj, i )
{
pName = Vec_StrEntryP( vOut, Pos );
NameId = Abc_NamStrFindOrAdd( p->pStrs, pName, NULL );
Pos += strlen(pName) + 1;
}
Cba_NtkForEachPoMain( pNtk, iObj, i )
{
pName = Vec_StrEntryP( vOut, Pos );
NameId = Abc_NamStrFindOrAdd( p->pStrs, pName, NULL );
Pos += strlen(pName) + 1;
}
Cba_NtkForEachBox( pNtk, iObj )
{
pName = Vec_StrEntryP( vOut, Pos );
NameId = Abc_NamStrFindOrAdd( p->pStrs, pName, NULL );
Pos += strlen(pName) + 1;
}
*/
}
Cba_Man_t * Cba_ManReadCbaInt( Vec_Str_t * vOut )
{
Cba_Man_t * p;
Cba_Ntk_t * pNtk;
char Buffer[1000] = "#";
int i, NameId, Pos = 0, nNtks, Num1, Num2, Num3, Num4;
while ( Buffer[0] == '#' )
if ( !CbaManReadCbaLine(vOut, &Pos, Buffer, Buffer+1000) )
return NULL;
if ( !CbaManReadCbaNameAndNums(Buffer, &nNtks, &Num2, &Num3, &Num4) )
return NULL;
// start manager
assert( nNtks > 0 );
p = Cba_ManAlloc( Buffer, nNtks );
// start networks
Cba_ManForEachNtk( p, pNtk, i )
{
if ( !CbaManReadCbaLine(vOut, &Pos, Buffer, Buffer+1000) )
{
Cba_ManFree( p );
return NULL;
}
if ( !CbaManReadCbaNameAndNums(Buffer, &Num1, &Num2, &Num3, &Num4) )
{
Cba_ManFree( p );
return NULL;
}
assert( Num1 >= 0 && Num2 >= 0 && Num3 >= 0 );
NameId = Abc_NamStrFindOrAdd( p->pStrs, Buffer, NULL );
Cba_NtkAlloc( pNtk, NameId, Num1, Num2, Num3 );
Vec_IntFill( &pNtk->vInfo, 3 * Num4, -1 );
}
// read networks
Cba_ManForEachNtk( p, pNtk, i )
Cba_ManReadCbaNtk( vOut, &Pos, pNtk );
assert( Cba_ManNtkNum(p) == nNtks );
assert( Pos == Vec_StrSize(vOut) );
return p;
}
Cba_Man_t * Cba_ManReadCba( char * pFileName )
{
Cba_Man_t * p;
FILE * pFile;
Vec_Str_t * vOut;
int nFileSize;
pFile = fopen( pFileName, "rb" );
if ( pFile == NULL )
{
printf( "Cannot open file \"%s\" for reading.\n", pFileName );
return NULL;
}
// get the file size, in bytes
fseek( pFile, 0, SEEK_END );
nFileSize = ftell( pFile );
rewind( pFile );
// load the contents
vOut = Vec_StrAlloc( nFileSize );
vOut->nSize = vOut->nCap;
assert( nFileSize == Vec_StrSize(vOut) );
nFileSize = fread( Vec_StrArray(vOut), 1, Vec_StrSize(vOut), pFile );
assert( nFileSize == Vec_StrSize(vOut) );
fclose( pFile );
// read the networks
p = Cba_ManReadCbaInt( vOut );
if ( p != NULL )
{
ABC_FREE( p->pSpec );
p->pSpec = Abc_UtilStrsav( pFileName );
}
Vec_StrFree( vOut );
return p;
}
/**Function*************************************************************
Synopsis [Write CBA.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Cba_ManWriteCbaNtk( Vec_Str_t * vOut, Cba_Ntk_t * pNtk )
{
//char * pName; int iObj, NameId;
Vec_StrPushBuffer( vOut, (char *)Vec_StrArray(&pNtk->vType), Cba_NtkObjNum(pNtk) );
Vec_StrPushBuffer( vOut, (char *)Vec_IntArray(&pNtk->vFanin), 4 * Cba_NtkObjNum(pNtk) );
Vec_StrPushBuffer( vOut, (char *)Vec_IntArray(&pNtk->vInfo), 12 * Cba_NtkInfoNum(pNtk) );
/*
// write input/output/box names
Cba_NtkForEachPiMain( pNtk, iObj, i )
{
pName = Cba_ObjNameStr( pNtk, iObj );
Vec_StrPrintStr( vOut, pName );
Vec_StrPush( vOut, '\0' );
}
Cba_NtkForEachPoMain( pNtk, iObj, i )
{
pName = Cba_ObjNameStr( pNtk, iObj );
Vec_StrPrintStr( vOut, pName );
Vec_StrPush( vOut, '\0' );
}
Cba_NtkForEachBox( pNtk, iObj )
{
pName = Cba_ObjNameStr( pNtk, iObj );
Vec_StrPrintStr( vOut, pName );
Vec_StrPush( vOut, '\0' );
}
*/
}
void Cba_ManWriteCbaInt( Vec_Str_t * vOut, Cba_Man_t * p )
{
char Buffer[1000];
Cba_Ntk_t * pNtk; int i;
sprintf( Buffer, "# Design \"%s\" written by ABC on %s\n", Cba_ManName(p), Extra_TimeStamp() );
Vec_StrPrintStr( vOut, Buffer );
// write short info
sprintf( Buffer, "%s %d \n", Cba_ManName(p), Cba_ManNtkNum(p) );
Vec_StrPrintStr( vOut, Buffer );
Cba_ManForEachNtk( p, pNtk, i )
{
sprintf( Buffer, "%s %d %d %d %d \n", Cba_NtkName(pNtk),
Cba_NtkPiNum(pNtk), Cba_NtkPoNum(pNtk), Cba_NtkObjNum(pNtk), Cba_NtkInfoNum(pNtk) );
Vec_StrPrintStr( vOut, Buffer );
}
Cba_ManForEachNtk( p, pNtk, i )
Cba_ManWriteCbaNtk( vOut, pNtk );
}
void Cba_ManWriteCba( char * pFileName, Cba_Man_t * p )
{
Vec_Str_t * vOut;
assert( p->pMioLib == NULL );
vOut = Vec_StrAlloc( 10000 );
Cba_ManWriteCbaInt( vOut, p );
if ( Vec_StrSize(vOut) > 0 )
{
FILE * pFile = fopen( pFileName, "wb" );
if ( pFile == NULL )
printf( "Cannot open file \"%s\" for writing.\n", pFileName );
else
{
fwrite( Vec_StrArray(vOut), 1, Vec_StrSize(vOut), pFile );
fclose( pFile );
}
}
Vec_StrFree( vOut );
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
......
src/base/cba/cbaCom.c
......@@ -47,48 +47,6 @@ static inline void Cba_AbcUpdateMan( Abc_Frame_t * pAbc, Cba_Man_t * p )
/**Function********************************************************************
Synopsis [Accessing current Cba_Ntk_t.]
Description []
SideEffects []
SeeAlso []
******************************************************************************/
void Abc_FrameImportPtr( Vec_Ptr_t * vPtr )
{
Cba_Man_t * p;
if ( Abc_FrameGetGlobalFrame() == NULL )
{
printf( "ABC framework is not started.\n" );
return;
}
p = Cba_PtrTransformToCba( vPtr );
if ( p == NULL )
printf( "Converting from Ptr failed.\n" );
Cba_AbcUpdateMan( Abc_FrameGetGlobalFrame(), p );
}
Vec_Ptr_t * Abc_FrameExportPtr()
{
Vec_Ptr_t * vPtr;
Cba_Man_t * p;
if ( Abc_FrameGetGlobalFrame() == NULL )
{
printf( "ABC framework is not started.\n" );
return NULL;
}
p = Cba_AbcGetMan( Abc_FrameGetGlobalFrame() );
if ( p == NULL )
printf( "There is no CBA design present.\n" );
vPtr = Cba_PtrDeriveFromCba( p );
if ( vPtr == NULL )
printf( "Converting to Ptr has failed.\n" );
return vPtr;
}
/**Function********************************************************************
Synopsis []
Description []
......@@ -181,6 +139,8 @@ int Cba_CommandRead( Abc_Frame_t * pAbc, int argc, char ** argv )
return 0;
}
fclose( pFile );
#if 0
// perform reading
if ( fUseAbc || fUsePtr )
{
......@@ -230,6 +190,8 @@ int Cba_CommandRead( Abc_Frame_t * pAbc, int argc, char ** argv )
return 0;
}
Cba_AbcUpdateMan( pAbc, p );
#endif
return 0;
usage:
Abc_Print( -2, "usage: @read [-apvh] <file_name>\n" );
......@@ -284,6 +246,8 @@ int Cba_CommandWrite( Abc_Frame_t * pAbc, int argc, char ** argv )
Abc_Print( 1, "Cba_CommandWrite(): There is no current design.\n" );
return 0;
}
#if 0
if ( argc == globalUtilOptind + 1 )
pFileName = argv[globalUtilOptind];
else if ( argc == globalUtilOptind && p )
......@@ -319,6 +283,8 @@ int Cba_CommandWrite( Abc_Frame_t * pAbc, int argc, char ** argv )
printf( "Unrecognized output file extension.\n" );
return 0;
}
#endif
return 0;
usage:
Abc_Print( -2, "usage: @write [-apvh]\n" );
......@@ -376,7 +342,11 @@ int Cba_CommandPs( Abc_Frame_t * pAbc, int argc, char ** argv )
Abc_Print( 1, "Cba_CommandPs(): There is no current design.\n" );
return 0;
}
#if 0
Cba_ManPrintStats( p, nModules, fVerbose );
#endif
return 0;
usage:
Abc_Print( -2, "usage: @ps [-M num] [-vh]\n" );
......@@ -425,6 +395,8 @@ int Cba_CommandPut( Abc_Frame_t * pAbc, int argc, char ** argv )
Abc_Print( 1, "Cba_CommandPut(): There is no current design.\n" );
return 0;
}
#if 0
pGia = Cba_ManExtract( p, fBarBufs, fVerbose );
if ( pGia == NULL )
{
......@@ -432,6 +404,8 @@ int Cba_CommandPut( Abc_Frame_t * pAbc, int argc, char ** argv )
return 0;
}
Abc_FrameUpdateGia( pAbc, pGia );
#endif
return 0;
usage:
Abc_Print( -2, "usage: @put [-bvh]\n" );
......@@ -479,6 +453,8 @@ int Cba_CommandGet( Abc_Frame_t * pAbc, int argc, char ** argv )
Abc_Print( 1, "Cba_CommandGet(): There is no current design.\n" );
return 0;
}
#if 0
if ( fMapped )
{
if ( pAbc->pNtkCur == NULL )
......@@ -498,10 +474,12 @@ int Cba_CommandGet( Abc_Frame_t * pAbc, int argc, char ** argv )
pNew = Cba_ManInsertGia( p, pAbc->pGia );
}
Cba_AbcUpdateMan( pAbc, pNew );
#endif
return 0;
usage:
Abc_Print( -2, "usage: @get [-mvh]\n" );
Abc_Print( -2, "\t inserts AIG or mapped network into the hierarchical design\n" );
Abc_Print( -2, "\t extracts AIG or mapped network into the hierarchical design\n" );
Abc_Print( -2, "\t-m : toggle using mapped network from main-space [default = %s]\n", fMapped? "yes": "no" );
Abc_Print( -2, "\t-v : toggle printing verbose information [default = %s]\n", fVerbose? "yes": "no" );
Abc_Print( -2, "\t-h : print the command usage\n");
......@@ -542,8 +520,12 @@ int Cba_CommandClp( Abc_Frame_t * pAbc, int argc, char ** argv )
Abc_Print( 1, "Cba_CommandGet(): There is no current design.\n" );
return 0;
}
#if 0
pNew = Cba_ManCollapse( p );
Cba_AbcUpdateMan( pAbc, pNew );
#endif
return 0;
usage:
Abc_Print( -2, "usage: @clp [-vh]\n" );
......@@ -593,6 +575,8 @@ int Cba_CommandCec( Abc_Frame_t * pAbc, int argc, char ** argv )
Abc_Print( 1, "Cba_CommandCec(): There is no current design.\n" );
return 0;
}
#if 0
pArgvNew = argv + globalUtilOptind;
nArgcNew = argc - globalUtilOptind;
if ( nArgcNew != 1 )
......@@ -658,6 +642,8 @@ int Cba_CommandCec( Abc_Frame_t * pAbc, int argc, char ** argv )
}
Gia_ManStop( pFirst );
Gia_ManStop( pSecond );
#endif
return 0;
usage:
Abc_Print( -2, "usage: @cec [-vh]\n" );
......@@ -680,10 +666,7 @@ usage:
******************************************************************************/
int Cba_CommandTest( Abc_Frame_t * pAbc, int argc, char ** argv )
{
extern void Prs_ManReadBlifTest();
extern void Prs_ManReadVerilogTest();
extern void Prs_SmtReadSmtTest();
//Cba_Man_t * p = Cba_AbcGetMan(pAbc);
Cba_Man_t * p = Cba_AbcGetMan(pAbc);
int c, fVerbose = 0;
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "vh" ) ) != EOF )
......@@ -699,16 +682,11 @@ int Cba_CommandTest( Abc_Frame_t * pAbc, int argc, char ** argv )
goto usage;
}
}
/*
if ( p == NULL )
{
Abc_Print( 1, "Cba_CommandTest(): There is no current design.\n" );
return 0;
}
*/
//Cba_PtrTransformTestTest();
//Prs_ManReadVerilogTest();
//Prs_SmtReadSmtTest();
return 0;
usage:
Abc_Print( -2, "usage: @test [-vh]\n" );
......
src/base/cba/cbaNtk.c
/**CFile****************************************************************
FileName [cbaNtk.c]
FileName [cba.c]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Hierarchical word-level netlist.]
PackageName [Verilog parser.]
Synopsis [Netlist manipulation.]
Synopsis [Parses several flavors of word-level Verilog.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - November 29, 2014.]
Date [Ver. 1.0. Started - July 21, 2015.]
Revision [$Id: cbaNtk.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
Revision [$Id: cba.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
***********************************************************************/
......@@ -26,491 +26,12 @@ ABC_NAMESPACE_IMPL_START
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
typedef struct Cba_Pair_t_ Cba_Pair_t;
struct Cba_Pair_t_
{
Cba_ObjType_t Type;
char * pName;
char * pSymb;
};
static const char * s_Pref = "ABC_";
static Cba_Pair_t s_Types[CBA_BOX_UNKNOWN] =
{
{ CBA_OBJ_NONE, "NONE", NULL },
{ CBA_OBJ_PI, "PI", NULL },
{ CBA_OBJ_PO, "PO", NULL },
{ CBA_OBJ_BI, "BI", NULL },
{ CBA_OBJ_BO, "BO", NULL },
{ CBA_OBJ_BOX, "BOX", NULL },
{ CBA_BOX_CF, "CF", "o" },
{ CBA_BOX_CT, "CT", "o" },
{ CBA_BOX_CX, "CX", "o" },
{ CBA_BOX_CZ, "CZ", "o" },
{ CBA_BOX_BUF, "BUF", "ao" },
{ CBA_BOX_INV, "INV", "ao" },
{ CBA_BOX_AND, "AND", "abo" },
{ CBA_BOX_NAND, "NAND", "abo" },
{ CBA_BOX_OR, "OR", "abo" },
{ CBA_BOX_NOR, "NOR", "abo" },
{ CBA_BOX_XOR, "XOR", "abo" },
{ CBA_BOX_XNOR, "XNOR", "abo" },
{ CBA_BOX_SHARP, "SHARP", "abo" },
{ CBA_BOX_SHARPL, "SHARPL", "abo" },
{ CBA_BOX_MUX, "MUX", "cabo" },
{ CBA_BOX_MAJ, "MAJ", "abco" },
{ CBA_BOX_RAND, "RAND", "ao" },
{ CBA_BOX_RNAND, "RNAND", "ao" },
{ CBA_BOX_ROR, "ROR", "ao" },
{ CBA_BOX_RNOR, "RNOR", "ao" },
{ CBA_BOX_RXOR, "RXOR", "ao" },
{ CBA_BOX_RXNOR, "RXNOR", "ao" },
{ CBA_BOX_LAND, "LAND", "abo" },
{ CBA_BOX_LNAND, "LNAND", "abo" },
{ CBA_BOX_LOR, "LOR", "abo" },
{ CBA_BOX_LNOR, "LNOR", "abo" },
{ CBA_BOX_LXOR, "LXOR", "abo" },
{ CBA_BOX_LXNOR, "LXNOR", "abo" },
{ CBA_BOX_NMUX, "NMUX", "abo" },
{ CBA_BOX_SEL, "SEL", "abo" },
{ CBA_BOX_PSEL, "PSEL", "iabo" },
{ CBA_BOX_ENC, "ENC", "ao" },
{ CBA_BOX_PENC, "PENC", "ao" },
{ CBA_BOX_DEC, "DEC", "ao" },
{ CBA_BOX_EDEC, "EDEC", "abo" },
{ CBA_BOX_ADD, "ADD", "iabso" },
{ CBA_BOX_SUB, "SUB", "abo" },
{ CBA_BOX_MUL, "MUL", "abo" },
{ CBA_BOX_DIV, "DIV", "abo" },
{ CBA_BOX_MOD, "MOD", "abo" },
{ CBA_BOX_REM, "REM", "abo" },
{ CBA_BOX_POW, "POW", "abo" },
{ CBA_BOX_MIN, "MIN", "ao" },
{ CBA_BOX_ABS, "ABS", "ao" },
{ CBA_BOX_LTHAN, "LTHAN", "iabo" },
{ CBA_BOX_LETHAN, "LETHAN", "abo" },
{ CBA_BOX_METHAN, "METHAN", "abo" },
{ CBA_BOX_MTHAN, "MTHAN", "abo" },
{ CBA_BOX_EQU, "EQU", "abo" },
{ CBA_BOX_NEQU, "NEQU", "abo" },
{ CBA_BOX_SHIL, "SHIL", "abo" },
{ CBA_BOX_SHIR, "SHIR", "abo" },
{ CBA_BOX_ROTL, "ROTL", "abo" },
{ CBA_BOX_ROTR, "ROTR", "abo" },
{ CBA_BOX_GATE, "GATE", "io" },
{ CBA_BOX_LUT, "LUT", "io" },
{ CBA_BOX_ASSIGN, "ASSIGN", "abo" },
{ CBA_BOX_TRI, "TRI", "abo" },
{ CBA_BOX_RAM, "RAM", "eadro" },
{ CBA_BOX_RAMR, "RAMR", "eamo" },
{ CBA_BOX_RAMW, "RAMW", "eado" },
{ CBA_BOX_RAMWC, "RAMWC", "ceado" },
{ CBA_BOX_RAMBOX, "RAMBOX", "io" },
{ CBA_BOX_LATCH, "LATCH", "dvsgq" },
{ CBA_BOX_LATCHRS, "LATCHRS", "dsrgq" },
{ CBA_BOX_DFF, "DFF", "dvscq" },
{ CBA_BOX_DFFRS, "DFFRS", "dsrcq" }
};
static inline int Cba_GetTypeId( Cba_ObjType_t Type )
{
int i;
for ( i = 1; i < CBA_BOX_UNKNOWN; i++ )
if ( s_Types[i].Type == Type )
return i;
return -1;
}
void Cba_ManSetupTypes( char ** pNames, char ** pSymbs )
{
Cba_ObjType_t Type;
for ( Type = 1; Type < CBA_BOX_UNKNOWN; Type++ )
{
int Id = Cba_GetTypeId( Type );
pNames[Type] = s_Types[Id].pName;
pSymbs[Type] = s_Types[Id].pSymb;
}
}
char * Cba_NtkGenerateName( Cba_Ntk_t * p, Cba_ObjType_t Type, Vec_Int_t * vBits )
{
static char Buffer[100];
char * pTemp; int i, Bits;
char * pName = Cba_ManPrimName( p->pDesign, Type );
char * pSymb = Cba_ManPrimSymb( p->pDesign, Type );
assert( Vec_IntSize(vBits) == (int)strlen(pSymb) );
sprintf( Buffer, "%s%s_", s_Pref, pName );
pTemp = Buffer + strlen(Buffer);
Vec_IntForEachEntry( vBits, Bits, i )
{
sprintf( pTemp, "%c%d", pSymb[i], Bits );
pTemp += strlen(pTemp);
}
//Vec_IntPrint( vBits );
//printf( "%s\n", Buffer );
return Buffer;
}
Cba_ObjType_t Cba_NameToType( char * pName )
{
Cba_ObjType_t i;
if ( strncmp(pName, s_Pref, strlen(s_Pref)) )
return 0;
pName += strlen(s_Pref);
for ( i = 1; i < CBA_BOX_UNKNOWN; i++ )
if ( !strncmp(pName, s_Types[i].pName, strlen(s_Types[i].pName)) )
return s_Types[i].Type;
return 0;
}
Vec_Int_t * Cba_NameToRanges( char * pName )
{
static Vec_Int_t Bits, * vBits = &Bits;
static int pArray[10];
char * pTemp;
int Num = 0, Count = 0;
// initialize array
vBits->pArray = pArray;
vBits->nSize = 0;
vBits->nCap = 10;
// check the name
assert( !strncmp(pName, s_Pref, strlen(s_Pref)) );
for ( pTemp = pName; *pTemp && !Cba_CharIsDigit(*pTemp); pTemp++ );
assert( Cba_CharIsDigit(*pTemp) );
for ( ; *pTemp; pTemp++ )
{
if ( Cba_CharIsDigit(*pTemp) )
Num = 10 * Num + *pTemp - '0';
else
Vec_IntPush( vBits, Num ), Count += Num, Num = 0;
}
assert( Num > 0 );
Vec_IntPush( vBits, Num ); Count += Num;
assert( Vec_IntSize(vBits) <= 10 );
return vBits;
}
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Replaces fanin iOld by iNew in all fanouts.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Cba_NtkUpdateFanout( Cba_Ntk_t * p, int iOld, int iNew )
{
int iCo;
assert( Cba_ObjIsCi(p, iOld) );
assert( Cba_ObjIsCi(p, iNew) );
Cba_ObjForEachFanout( p, iOld, iCo )
{
assert( Cba_ObjFanin(p, iCo) == iOld );
Cba_ObjCleanFanin( p, iCo );
Cba_ObjSetFanin( p, iCo, iNew );
}
Cba_ObjSetFanout( p, iNew, Cba_ObjFanout(p, iOld) );
Cba_ObjSetFanout( p, iOld, 0 );
}
/**Function*************************************************************
Synopsis [Derives fanout.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Cba_NtkDeriveFanout( Cba_Ntk_t * p )
{
int iCi, iCo;
assert( !Cba_NtkHasFanouts(p) );
Cba_NtkStartFanouts( p );
Cba_NtkForEachCo( p, iCo )
{
assert( !Cba_ObjNextFanout(p, iCo) );
iCi = Cba_ObjFanin(p, iCo);
if ( Cba_ObjFanout(p, iCi) )
Cba_ObjSetNextFanout( p, Cba_ObjFanout(p, iCi), iCo );
Cba_ObjSetFanout( p, iCi, iCo );
}
Cba_NtkForEachCo( p, iCo )
if ( !Cba_ObjNextFanout(p, iCo) )
Cba_ObjSetFanout( p, Cba_ObjFanin(p, iCo), iCo );
}
void Cba_ManDeriveFanout( Cba_Man_t * p )
{
Cba_Ntk_t * pNtk; int i;
Cba_ManForEachNtk( p, pNtk, i )
Cba_NtkDeriveFanout( pNtk );
}
/**Function*************************************************************
Synopsis [Assigns word-level names.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Cba_ManAssignInternTwo( Cba_Ntk_t * p, int iNum, int nDigits, char * pPref, Vec_Int_t * vMap )
{
char Buffer[16]; int i, NameId = 0;
for ( i = 0; !NameId || Vec_IntEntry(vMap, NameId); i++ )
{
if ( i == 0 )
sprintf( Buffer, "%s%0*d", pPref, nDigits, iNum );
else
sprintf( Buffer, "%s%0*d_%d", pPref, nDigits, iNum, i );
NameId = Abc_NamStrFindOrAdd( p->pDesign->pStrs, Buffer, NULL );
}
Vec_IntWriteEntry( vMap, NameId, 1 );
return NameId;
}
int Cba_ManAssignCountNames( Cba_Ntk_t * p )
{
int i, iObj, iBox, Count = 0;
Cba_NtkForEachPiMain( p, iObj, i )
if ( !Cba_ObjNameInt(p, iObj) )
Count++;
Cba_NtkForEachBox( p, iBox )
Cba_BoxForEachBoMain( p, iBox, iObj, i )
if ( !Cba_ObjNameInt(p, iObj) )
Count++;
return Count;
}
void Cba_ManAssignInternWordNamesNtk( Cba_Ntk_t * p, Vec_Int_t * vMap )
{
int k, iObj, iTerm, iName = -1, iBit = -1;
int nDigits, nPis = 0, nPos = 0, nNames = 1;
// start names
if ( !Cba_NtkHasNames(p) )
Cba_NtkStartNames(p);
nDigits = Abc_Base10Log( Cba_ManAssignCountNames(p) );
// populate map with the currently used names
Cba_NtkForEachCi( p, iObj )
if ( Cba_ObjNameInt(p, iObj) )
Vec_IntWriteEntry( vMap, Cba_ObjNameId(p, iObj), 1 );
Cba_NtkForEachBox( p, iObj )
if ( Cba_ObjNameInt(p, iObj) )
Vec_IntWriteEntry( vMap, Cba_ObjNameId(p, iObj), 1 );
// assign CI names
Cba_NtkForEachCi( p, iObj )
{
if ( Cba_ObjNameInt(p, iObj) )
{
iName = -1;
iBit = -1;
continue;
}
if ( Cba_ObjBit(p, iObj) )
{
assert( iBit > 0 );
Cba_ObjSetName( p, iObj, Abc_Var2Lit2(iBit++, CBA_NAME_INDEX) );
}
else
{
//int Type = Cba_ObjType(p, iObj);
int Range = Cba_ObjIsPi(p, iObj) ? Cba_ObjPiRange(p, iObj) : Cba_BoxBoRange(p, iObj);
iName = Cba_ManAssignInternTwo( p, nNames++, nDigits, (char*)(Cba_ObjIsPi(p, iObj) ? "i":"n"), vMap );
if ( Range == 1 )
Cba_ObjSetName( p, iObj, Abc_Var2Lit2(iName, CBA_NAME_BIN) );
else
Cba_ObjSetName( p, iObj, Abc_Var2Lit2(iName, CBA_NAME_WORD) );
iBit = 1;
}
}
// transfer names to the interface
if ( Cba_NtkInfoNum(p) )
{
for ( k = 0; k < Cba_NtkInfoNum(p); k++ )
{
//char * pName = Cba_NtkName(p);
if ( Cba_NtkInfoType(p, k) == 1 ) // PI
{
iObj = Cba_NtkPi(p, nPis);
assert( !Cba_ObjBit(p, iObj) );
assert( Cba_ObjNameType(p, iObj) <= CBA_NAME_WORD );
Cba_NtkSetInfoName( p, k, Abc_Var2Lit2(Cba_ObjNameId(p, iObj), 1) );
nPis += Cba_NtkInfoRange(p, k);
}
else if ( Cba_NtkInfoType(p, k) == 2 ) // PO
{
iObj = Cba_NtkPo(p, nPos);
assert( !Cba_ObjBit(p, iObj) );
iObj = Cba_ObjFanin(p, iObj);
assert( Cba_ObjNameType(p, iObj) <= CBA_NAME_WORD );
Cba_NtkSetInfoName( p, k, Abc_Var2Lit2(Cba_ObjNameId(p, iObj), 2) );
nPos += Cba_NtkInfoRange(p, k);
}
else assert( 0 );
}
assert( nPis == Cba_NtkPiNum(p) );
assert( nPos == Cba_NtkPoNum(p) );
}
// assign instance names
nDigits = Abc_Base10Log( Cba_NtkObjNum(p) );
Cba_NtkForEachBox( p, iObj )
if ( !Cba_ObjNameInt(p, iObj) )
{
iName = Cba_ManAssignInternTwo( p, iObj, nDigits, "g", vMap );
Cba_ObjSetName( p, iObj, Abc_Var2Lit2(iName, CBA_NAME_BIN) );
}
// unmark all names
Cba_NtkForEachPi( p, iObj, k )
if ( Cba_ObjNameType(p, iObj) <= CBA_NAME_WORD )
Vec_IntWriteEntry( vMap, Cba_ObjNameId(p, iObj), 0 );
Cba_NtkForEachBox( p, iObj )
{
Vec_IntWriteEntry( vMap, Cba_ObjNameId(p, iObj), 0 );
Cba_BoxForEachBo( p, iObj, iTerm, k )
if ( Cba_ObjNameType(p, iTerm) <= CBA_NAME_WORD )
Vec_IntWriteEntry( vMap, Cba_ObjNameId(p, iTerm), 0 );
}
// printf( "Generated %d word-level names.\n", nNames-1 );
}
void Cba_ManAssignInternWordNames( Cba_Man_t * p )
{
Vec_Int_t * vMap = Vec_IntStart( 2*Cba_ManObjNum(p) );
Cba_Ntk_t * pNtk; int i;
Cba_ManForEachNtk( p, pNtk, i )
Cba_ManAssignInternWordNamesNtk( pNtk, vMap );
assert( Vec_IntCountEntry(vMap, 0) == Vec_IntSize(vMap) );
Vec_IntFree( vMap );
}
/**Function*************************************************************
Synopsis [Count number of objects after collapsing.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Cba_ManClpObjNum_rec( Cba_Ntk_t * p )
{
int i, Counter = 0;
if ( p->Count >= 0 )
return p->Count;
Cba_NtkForEachBox( p, i )
Counter += Cba_ObjIsBoxUser(p, i) ? Cba_ManClpObjNum_rec( Cba_BoxNtk(p, i) ) + 3*Cba_BoxBoNum(p, i) : Cba_BoxSize(p, i);
return (p->Count = Counter);
}
int Cba_ManClpObjNum( Cba_Man_t * p )
{
Cba_Ntk_t * pNtk; int i;
Cba_ManForEachNtk( p, pNtk, i )
pNtk->Count = -1;
return Cba_NtkPioNum( Cba_ManRoot(p) ) + Cba_ManClpObjNum_rec( Cba_ManRoot(p) );
}
/**Function*************************************************************
Synopsis [Collects boxes in the DFS order.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Cba_NtkDfs_rec( Cba_Ntk_t * p, int iObj, Vec_Int_t * vBoxes )
{
int k, iFanin;
if ( Cba_ObjIsBo(p, iObj) == 1 )
{
Cba_NtkDfs_rec( p, Cba_ObjFanin(p, iObj), vBoxes );
return;
}
assert( Cba_ObjIsPi(p, iObj) || Cba_ObjIsBox(p, iObj) );
if ( Cba_ObjCopy(p, iObj) > 0 ) // visited
return;
Cba_ObjSetCopy( p, iObj, 1 );
Cba_BoxForEachFanin( p, iObj, iFanin, k )
Cba_NtkDfs_rec( p, iFanin, vBoxes );
Vec_IntPush( vBoxes, iObj );
}
Vec_Int_t * Cba_NtkDfs( Cba_Ntk_t * p )
{
int i, iObj;
Vec_Int_t * vBoxes = Vec_IntAlloc( Cba_NtkBoxNum(p) );
Cba_NtkStartCopies( p ); // -1 = not visited; 1 = finished
Cba_NtkForEachPi( p, iObj, i )
Cba_ObjSetCopy( p, iObj, 1 );
Cba_NtkForEachPo( p, iObj, i )
Cba_NtkDfs_rec( p, Cba_ObjFanin(p, iObj), vBoxes );
return vBoxes;
}
/**Function*************************************************************
Synopsis [Collects user boxes in the DFS order.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Cba_NtkDfsUserBoxes_rec( Cba_Ntk_t * p, int iObj, Vec_Int_t * vBoxes )
{
int k, iFanin;
assert( Cba_ObjIsBoxUser(p, iObj) );
if ( Cba_ObjCopy(p, iObj) == 1 ) // visited
return 1;
if ( Cba_ObjCopy(p, iObj) == 0 ) // loop
return 0;
Cba_ObjSetCopy( p, iObj, 0 );
Cba_BoxForEachFanin( p, iObj, iFanin, k )
if ( Cba_ObjIsBo(p, iFanin) && Cba_ObjIsBoxUser(p, Cba_ObjFanin(p, iFanin)) )
if ( !Cba_NtkDfsUserBoxes_rec( p, Cba_ObjFanin(p, iFanin), vBoxes ) )
return 0;
Vec_IntPush( vBoxes, iObj );
Cba_ObjSetCopy( p, iObj, 1 );
return 1;
}
int Cba_NtkDfsUserBoxes( Cba_Ntk_t * p )
{
int iObj;
Cba_NtkStartCopies( p ); // -1 = not visited; 0 = on the path; 1 = finished
Vec_IntClear( &p->vArray );
Cba_NtkForEachBoxUser( p, iObj )
if ( !Cba_NtkDfsUserBoxes_rec( p, iObj, &p->vArray ) )
{
printf( "Cyclic dependency of user boxes is detected.\n" );
return 0;
}
return 1;
}
/**Function*************************************************************
Synopsis []
Description []
......@@ -520,80 +41,6 @@ int Cba_NtkDfsUserBoxes( Cba_Ntk_t * p )
SeeAlso []
***********************************************************************/
void Cba_NtkCollapse_rec( Cba_Ntk_t * pNew, Cba_Ntk_t * p, Vec_Int_t * vSigs )
{
int i, iObj, iObjNew, iTerm;
Cba_NtkStartCopies( p );
// set PI copies
assert( Vec_IntSize(vSigs) == Cba_NtkPiNum(p) );
Cba_NtkForEachPi( p, iObj, i )
Cba_ObjSetCopy( p, iObj, Vec_IntEntry(vSigs, i) );
// duplicate internal objects and create buffers for hierarchy instances
Cba_NtkForEachBox( p, iObj )
if ( Cba_ObjIsBoxPrim( p, iObj ) )
Cba_BoxDup( pNew, p, iObj );
else
{
Cba_BoxForEachBo( p, iObj, iTerm, i )
{
iObjNew = Cba_ObjAlloc( pNew, CBA_OBJ_BI, -1 );
iObjNew = Cba_ObjAlloc( pNew, CBA_BOX_BUF, -1 ); // buffer
iObjNew = Cba_ObjAlloc( pNew, CBA_OBJ_BO, -1 );
Cba_ObjSetCopy( p, iTerm, iObjNew );
}
}
// duplicate user modules and connect objects
Cba_NtkForEachBox( p, iObj )
if ( Cba_ObjIsBoxPrim( p, iObj ) )
{
Cba_BoxForEachBi( p, iObj, iTerm, i )
Cba_ObjSetFanin( pNew, Cba_ObjCopy(p, iTerm), Cba_ObjCopy(p, Cba_ObjFanin(p, iTerm)) );
}
else
{
Vec_IntClear( vSigs );
Cba_BoxForEachBi( p, iObj, iTerm, i )
Vec_IntPush( vSigs, Cba_ObjCopy(p, Cba_ObjFanin(p, iTerm)) );
Cba_NtkCollapse_rec( pNew, Cba_BoxNtk(p, iObj), vSigs );
assert( Vec_IntSize(vSigs) == Cba_BoxBoNum(p, iObj) );
Cba_BoxForEachBo( p, iObj, iTerm, i )
Cba_ObjSetFanin( pNew, Cba_ObjCopy(p, iTerm)-2, Vec_IntEntry(vSigs, i) );
}
// collect POs
Vec_IntClear( vSigs );
Cba_NtkForEachPo( p, iObj, i )
Vec_IntPush( vSigs, Cba_ObjCopy(p, Cba_ObjFanin(p, iObj)) );
}
Cba_Man_t * Cba_ManCollapse( Cba_Man_t * p )
{
int i, iObj;
Vec_Int_t * vSigs = Vec_IntAlloc( 1000 );
Cba_Man_t * pNew = Cba_ManStart( p, 1 );
Cba_Ntk_t * pRoot = Cba_ManRoot( p );
Cba_Ntk_t * pRootNew = Cba_ManRoot( pNew );
Cba_NtkAlloc( pRootNew, Cba_NtkNameId(pRoot), Cba_NtkPiNum(pRoot), Cba_NtkPoNum(pRoot), Cba_ManClpObjNum(p) );
if ( Vec_IntSize(&pRoot->vInfo) )
Vec_IntAppend( &pRootNew->vInfo, &pRoot->vInfo );
Cba_NtkForEachPi( pRoot, iObj, i )
Vec_IntPush( vSigs, Cba_ObjAlloc(pRootNew, CBA_OBJ_PI, -1) );
Cba_NtkCollapse_rec( pRootNew, pRoot, vSigs );
assert( Vec_IntSize(vSigs) == Cba_NtkPoNum(pRoot) );
Cba_NtkForEachPo( pRoot, iObj, i )
Cba_ObjAlloc( pRootNew, CBA_OBJ_PO, Vec_IntEntry(vSigs, i) );
assert( Cba_NtkObjNum(pRootNew) == Cba_NtkObjNumAlloc(pRootNew) );
Vec_IntFree( vSigs );
// transfer PI/PO names
if ( Cba_NtkHasNames(pRoot) )
{
Cba_NtkStartNames( pRootNew );
Cba_NtkForEachPi( pRoot, iObj, i )
Cba_ObjSetName( pRootNew, Cba_NtkPi(pRootNew, i), Cba_ObjName(pRoot, iObj) );
Cba_NtkForEachPoDriver( pRoot, iObj, i )
if ( !Cba_ObjIsPi(pRoot, iObj) )
Cba_ObjSetName( pRootNew, Cba_ObjCopy(pRoot, iObj), Cba_ObjName(pRoot, iObj) );
}
return pNew;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
......
src/base/cba/cbaPrs.h
......@@ -288,6 +288,14 @@ static inline void Prs_NtkFree( Prs_Ntk_t * p )
ABC_FREE( p );
}
static inline void Prs_ManVecFree( Vec_Ptr_t * vPrs )
{
Prs_Ntk_t * pNtk; int i;
Vec_PtrForEachEntry( Prs_Ntk_t *, vPrs, pNtk, i )
Prs_NtkFree( pNtk );
Vec_PtrFree( vPrs );
}
static inline void Prs_ManFree( Prs_Man_t * p )
{
if ( p->pStrs )
......@@ -333,6 +341,100 @@ static inline int Prs_ManMemory( Vec_Ptr_t * vPrs )
}
/**Function*************************************************************
Synopsis [Other APIs.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline Cba_ObjType_t Ptr_SopToType( char * pSop )
{
if ( !strcmp(pSop, " 0\n") ) return CBA_BOX_CF;
if ( !strcmp(pSop, " 1\n") ) return CBA_BOX_CT;
if ( !strcmp(pSop, "1 1\n") ) return CBA_BOX_BUF;
if ( !strcmp(pSop, "0 1\n") ) return CBA_BOX_INV;
if ( !strcmp(pSop, "11 1\n") ) return CBA_BOX_AND;
if ( !strcmp(pSop, "00 1\n") ) return CBA_BOX_NOR;
if ( !strcmp(pSop, "00 0\n") ) return CBA_BOX_OR;
if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return CBA_BOX_OR;
if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return CBA_BOX_OR;
if ( !strcmp(pSop, "01 1\n10 1\n") ) return CBA_BOX_XOR;
if ( !strcmp(pSop, "10 1\n01 1\n") ) return CBA_BOX_XOR;
if ( !strcmp(pSop, "11 1\n00 1\n") ) return CBA_BOX_XNOR;
if ( !strcmp(pSop, "00 1\n11 1\n") ) return CBA_BOX_XNOR;
if ( !strcmp(pSop, "10 1\n") ) return CBA_BOX_SHARP;
if ( !strcmp(pSop, "01 1\n") ) return CBA_BOX_SHARPL;
assert( 0 );
return CBA_OBJ_NONE;
}
static inline char * Ptr_SopToTypeName( char * pSop )
{
if ( !strcmp(pSop, " 0\n") ) return "CBA_BOX_C0";
if ( !strcmp(pSop, " 1\n") ) return "CBA_BOX_C1";
if ( !strcmp(pSop, "1 1\n") ) return "CBA_BOX_BUF";
if ( !strcmp(pSop, "0 1\n") ) return "CBA_BOX_INV";
if ( !strcmp(pSop, "11 1\n") ) return "CBA_BOX_AND";
if ( !strcmp(pSop, "00 1\n") ) return "CBA_BOX_NOR";
if ( !strcmp(pSop, "00 0\n") ) return "CBA_BOX_OR";
if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return "CBA_BOX_OR";
if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return "CBA_BOX_OR";
if ( !strcmp(pSop, "01 1\n10 1\n") ) return "CBA_BOX_XOR";
if ( !strcmp(pSop, "10 1\n01 1\n") ) return "CBA_BOX_XOR";
if ( !strcmp(pSop, "11 1\n00 1\n") ) return "CBA_BOX_XNOR";
if ( !strcmp(pSop, "00 1\n11 1\n") ) return "CBA_BOX_XNOR";
if ( !strcmp(pSop, "10 1\n") ) return "CBA_BOX_SHARP";
if ( !strcmp(pSop, "01 1\n") ) return "CBA_BOX_SHARPL";
assert( 0 );
return NULL;
}
static inline char * Ptr_TypeToName( Cba_ObjType_t Type )
{
if ( Type == CBA_BOX_CF ) return "const0";
if ( Type == CBA_BOX_CT ) return "const1";
if ( Type == CBA_BOX_CX ) return "constX";
if ( Type == CBA_BOX_CZ ) return "constZ";
if ( Type == CBA_BOX_BUF ) return "buf";
if ( Type == CBA_BOX_INV ) return "not";
if ( Type == CBA_BOX_AND ) return "and";
if ( Type == CBA_BOX_NAND ) return "nand";
if ( Type == CBA_BOX_OR ) return "or";
if ( Type == CBA_BOX_NOR ) return "nor";
if ( Type == CBA_BOX_XOR ) return "xor";
if ( Type == CBA_BOX_XNOR ) return "xnor";
if ( Type == CBA_BOX_MUX ) return "mux";
if ( Type == CBA_BOX_MAJ ) return "maj";
if ( Type == CBA_BOX_SHARP ) return "sharp";
if ( Type == CBA_BOX_SHARPL) return "sharpl";
assert( 0 );
return "???";
}
static inline char * Ptr_TypeToSop( Cba_ObjType_t Type )
{
if ( Type == CBA_BOX_CF ) return " 0\n";
if ( Type == CBA_BOX_CT ) return " 1\n";
if ( Type == CBA_BOX_CX ) return " 0\n";
if ( Type == CBA_BOX_CZ ) return " 0\n";
if ( Type == CBA_BOX_BUF ) return "1 1\n";
if ( Type == CBA_BOX_INV ) return "0 1\n";
if ( Type == CBA_BOX_AND ) return "11 1\n";
if ( Type == CBA_BOX_NAND ) return "11 0\n";
if ( Type == CBA_BOX_OR ) return "00 0\n";
if ( Type == CBA_BOX_NOR ) return "00 1\n";
if ( Type == CBA_BOX_XOR ) return "01 1\n10 1\n";
if ( Type == CBA_BOX_XNOR ) return "00 1\n11 1\n";
if ( Type == CBA_BOX_SHARP ) return "10 1\n";
if ( Type == CBA_BOX_SHARPL) return "01 1\n";
if ( Type == CBA_BOX_MUX ) return "11- 1\n0-1 1\n";
if ( Type == CBA_BOX_MAJ ) return "11- 1\n1-1 1\n-11 1\n";
assert( 0 );
return "???";
}
////////////////////////////////////////////////////////////////////////
/// ITERATORS ///
......
src/base/cba/cbaReadBlif.c
......@@ -43,7 +43,7 @@ typedef enum {
PRS_BLIF_UNKNOWN // 11: unknown
} Cba_BlifType_t;
const char * s_BlifTypes[PRS_BLIF_UNKNOWN+1] = {
static const char * s_BlifTypes[PRS_BLIF_UNKNOWN+1] = {
NULL, // 0: unused
".model", // 1: .model
".inouts", // 2: .inputs
......
src/base/cba/cbaReadVer.c
......@@ -45,7 +45,7 @@ typedef enum {
PRS_VER_UNKNOWN // 13: unknown
} Cba_VerType_t;
const char * s_VerTypes[PRS_VER_UNKNOWN+1] = {
static const char * s_VerTypes[PRS_VER_UNKNOWN+1] = {
NULL, // 0: unused
"input", // 1: input
"output", // 2: output
......@@ -101,7 +101,7 @@ static inline int Prs_ManIsDigit( Prs_Man_t * p ) { return Prs_CharIsD
***********************************************************************/
// collect predefined modules names
const char * s_VerilogModules[100] =
static const char * s_VerilogModules[100] =
{
"const0", // CBA_BOX_CF,
"const1", // CBA_BOX_CT,
......@@ -120,7 +120,7 @@ const char * s_VerilogModules[100] =
"maj", // CBA_BOX_MAJ,
NULL
};
const char * s_KnownModules[100] =
static const char * s_KnownModules[100] =
{
"VERIFIC_",
"add_",
......@@ -447,7 +447,7 @@ static inline int Prs_ManReadSignal( Prs_Man_t * p )
return Abc_Var2Lit2( Item, CBA_PRS_NAME );
}
}
int Prs_ManReadSignalList( Prs_Man_t * p, Vec_Int_t * vTemp, char LastSymb, int fAddForm )
static int Prs_ManReadSignalList( Prs_Man_t * p, Vec_Int_t * vTemp, char LastSymb, int fAddForm )
{
Vec_IntClear( vTemp );
while ( 1 )
......
src/base/cba/cbaWriteBlif.c
......@@ -44,14 +44,14 @@ ABC_NAMESPACE_IMPL_START
SeeAlso []
***********************************************************************/
void Prs_ManWriteBlifArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vFanins )
static void Prs_ManWriteBlifArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vFanins )
{
int i, NameId;
Vec_IntForEachEntry( vFanins, NameId, i )
fprintf( pFile, " %s", Prs_NtkStr(p, NameId) );
fprintf( pFile, "\n" );
}
void Prs_ManWriteBlifLines( FILE * pFile, Prs_Ntk_t * p )
static void Prs_ManWriteBlifLines( FILE * pFile, Prs_Ntk_t * p )
{
Vec_Int_t * vBox;
int i, k, FormId, ActId;
......@@ -84,7 +84,7 @@ void Prs_ManWriteBlifLines( FILE * pFile, Prs_Ntk_t * p )
}
}
}
void Prs_ManWriteBlifNtk( FILE * pFile, Prs_Ntk_t * p )
static void Prs_ManWriteBlifNtk( FILE * pFile, Prs_Ntk_t * p )
{
// write header
fprintf( pFile, ".model %s\n", Prs_NtkStr(p, p->iModuleName) );
......@@ -116,6 +116,7 @@ void Prs_ManWriteBlif( char * pFileName, Vec_Ptr_t * vPrs )
}
#if 0
/**Function*************************************************************
......@@ -226,6 +227,7 @@ void Cba_ManWriteBlif( char * pFileName, Cba_Man_t * p )
fclose( pFile );
}
#endif
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
......
src/base/cba/cbaWriteVer.c
......@@ -44,7 +44,7 @@ ABC_NAMESPACE_IMPL_START
SeeAlso []
***********************************************************************/
void Prs_ManWriteVerilogConcat( FILE * pFile, Prs_Ntk_t * p, int Con )
static void Prs_ManWriteVerilogConcat( FILE * pFile, Prs_Ntk_t * p, int Con )
{
extern void Prs_ManWriteVerilogArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs, int Start, int Stop, int fOdd );
Vec_Int_t * vSigs = Prs_CatSignals(p, Con);
......@@ -52,7 +52,7 @@ void Prs_ManWriteVerilogConcat( FILE * pFile, Prs_Ntk_t * p, int Con )
Prs_ManWriteVerilogArray( pFile, p, vSigs, 0, Vec_IntSize(vSigs), 0 );
fprintf( pFile, "}" );
}
void Prs_ManWriteVerilogSignal( FILE * pFile, Prs_Ntk_t * p, int Sig )
static void Prs_ManWriteVerilogSignal( FILE * pFile, Prs_Ntk_t * p, int Sig )
{
int Value = Abc_Lit2Var2( Sig );
Prs_ManType_t Type = (Prs_ManType_t)Abc_Lit2Att2( Sig );
......@@ -64,7 +64,7 @@ void Prs_ManWriteVerilogSignal( FILE * pFile, Prs_Ntk_t * p, int Sig )
Prs_ManWriteVerilogConcat( pFile, p, Value );
else assert( 0 );
}
void Prs_ManWriteVerilogArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs, int Start, int Stop, int fOdd )
static void Prs_ManWriteVerilogArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs, int Start, int Stop, int fOdd )
{
int i, Sig;
assert( Vec_IntSize(vSigs) > 0 );
......@@ -76,7 +76,7 @@ void Prs_ManWriteVerilogArray( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs, i
fprintf( pFile, "%s", i == Stop - 1 ? "" : ", " );
}
}
void Prs_ManWriteVerilogArray2( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs )
static void Prs_ManWriteVerilogArray2( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs )
{
int i, FormId, ActSig;
assert( Vec_IntSize(vSigs) % 2 == 0 );
......@@ -89,7 +89,7 @@ void Prs_ManWriteVerilogArray2( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs )
fprintf( pFile, ")%s", (i == Vec_IntSize(vSigs) - 2) ? "" : ", " );
}
}
void Prs_ManWriteVerilogMux( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs )
static void Prs_ManWriteVerilogMux( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs )
{
int i, FormId, ActSig;
char * pStrs[4] = { " = ", " ? ", " : ", ";\n" };
......@@ -105,7 +105,7 @@ void Prs_ManWriteVerilogMux( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vSigs )
break;
}
}
void Prs_ManWriteVerilogBoxes( FILE * pFile, Prs_Ntk_t * p )
static void Prs_ManWriteVerilogBoxes( FILE * pFile, Prs_Ntk_t * p )
{
Vec_Int_t * vBox; int i;
Prs_NtkForEachBox( p, vBox, i )
......@@ -131,7 +131,7 @@ void Prs_ManWriteVerilogBoxes( FILE * pFile, Prs_Ntk_t * p )
}
}
}
void Prs_ManWriteVerilogIos( FILE * pFile, Prs_Ntk_t * p, int SigType )
static void Prs_ManWriteVerilogIos( FILE * pFile, Prs_Ntk_t * p, int SigType )
{
int NameId, RangeId, i;
char * pSigNames[4] = { "inout", "input", "output", "wire" };
......@@ -142,13 +142,13 @@ void Prs_ManWriteVerilogIos( FILE * pFile, Prs_Ntk_t * p, int SigType )
Vec_IntForEachEntryTwo( vSigs[SigType], vSigsR[SigType], NameId, RangeId, i )
fprintf( pFile, " %s %s%s;\n", pSigNames[SigType], RangeId ? Prs_NtkStr(p, RangeId) : "", Prs_NtkStr(p, NameId) );
}
void Prs_ManWriteVerilogIoOrder( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vOrder )
static void Prs_ManWriteVerilogIoOrder( FILE * pFile, Prs_Ntk_t * p, Vec_Int_t * vOrder )
{
int i, NameId;
Vec_IntForEachEntry( vOrder, NameId, i )
fprintf( pFile, "%s%s", Prs_NtkStr(p, NameId), i == Vec_IntSize(vOrder) - 1 ? "" : ", " );
}
void Prs_ManWriteVerilogNtk( FILE * pFile, Prs_Ntk_t * p )
static void Prs_ManWriteVerilogNtk( FILE * pFile, Prs_Ntk_t * p )
{
int s;
// write header
......@@ -179,6 +179,7 @@ void Prs_ManWriteVerilog( char * pFileName, Vec_Ptr_t * vPrs )
}
#if 0
/**Function*************************************************************
......@@ -693,6 +694,7 @@ void Cba_ManWriteVerilog( char * pFileName, Cba_Man_t * p, int fUseAssign )
Vec_StrFreeP( &p->vOut2 );
}
#endif
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
......
src/base/cba/module.make
SRC += src/base/cba/cbaBlast.c \
src/base/cba/cbaCba.c \
src/base/cba/cbaCom.c \
src/base/cba/cbaLib.c \
src/base/cba/cbaNtk.c \
src/base/cba/cbaPrsBuild.c \
src/base/cba/cbaPrsTrans.c \
src/base/cba/cbaPtr.c \
src/base/cba/cbaPtrAbc.c \
src/base/cba/cbaReadBlif.c \
src/base/cba/cbaReadSmt.c \
src/base/cba/cbaReadVer.c \
src/base/cba/cbaWriteBlif.c \
src/base/cba/cbaWriteSmt.c \
src/base/cba/cbaWriteVer.c
src/base/main/mainInit.c
......@@ -49,6 +49,8 @@ extern void Scl_Init( Abc_Frame_t * pAbc );
extern void Scl_End( Abc_Frame_t * pAbc );
extern void Wlc_Init( Abc_Frame_t * pAbc );
extern void Wlc_End( Abc_Frame_t * pAbc );
extern void Bac_Init( Abc_Frame_t * pAbc );
extern void Bac_End( Abc_Frame_t * pAbc );
extern void Cba_Init( Abc_Frame_t * pAbc );
extern void Cba_End( Abc_Frame_t * pAbc );
extern void Pla_Init( Abc_Frame_t * pAbc );
......@@ -108,6 +110,7 @@ void Abc_FrameInit( Abc_Frame_t * pAbc )
Load_Init( pAbc );
Scl_Init( pAbc );
Wlc_Init( pAbc );
Bac_Init( pAbc );
Cba_Init( pAbc );
Pla_Init( pAbc );
Test_Init( pAbc );
......@@ -145,6 +148,7 @@ void Abc_FrameEnd( Abc_Frame_t * pAbc )
Load_End( pAbc );
Scl_End( pAbc );
Wlc_End( pAbc );
Bac_End( pAbc );
Cba_End( pAbc );
Pla_End( pAbc );
Test_End( pAbc );
......
src/misc/vec/vecInt.h
......@@ -1939,6 +1939,27 @@ static inline void Vec_IntAppendSkip( Vec_Int_t * vVec1, Vec_Int_t * vVec2, int
Vec_IntPush( vVec1, Entry );
}
/**Function*************************************************************
Synopsis [Remapping attributes after objects were duplicated.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline void Vec_IntRemapArray( Vec_Int_t * vOld2New, Vec_Int_t * vOld, Vec_Int_t * vNew, int nNew )
{
int iOld, iNew;
if ( Vec_IntSize(vOld) == 0 )
return;
Vec_IntFill( vNew, nNew, 0 );
Vec_IntForEachEntry( vOld2New, iNew, iOld )
if ( iNew > 0 && iNew < nNew && Vec_IntEntry(vOld, iOld) != 0 )
Vec_IntWriteEntry( vNew, iNew, Vec_IntEntry(vOld, iOld) );
}
ABC_NAMESPACE_HEADER_END
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment