ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
cba.h
Go to the documentation of this file.
1
20
21#ifndef ABC__base__cba__cba_h
22#define ABC__base__cba__cba_h
23
27
28#include "aig/gia/gia.h"
29#include "misc/extra/extra.h"
30#include "misc/util/utilNam.h"
31#include "misc/vec/vecHash.h"
32#include "cbaTypes.h"
33
37
38ABC_NAMESPACE_HEADER_START
39
43
44
45typedef struct Cba_Ntk_t_ Cba_Ntk_t;
46typedef struct Cba_Man_t_ Cba_Man_t;
47
48// network
49struct Cba_Ntk_t_
50{
51 Cba_Man_t * pDesign; // design
52 int Id; // network ID
53 int NameId; // name ID
54 int iCopy; // copy module
55 unsigned Mark : 1; // visit mark
56 unsigned fComb: 1; // the network is combinational
57 unsigned fSeq : 1; // the network is sequential
58 // interface
59 Vec_Int_t vInputs; // inputs
60 Vec_Int_t vOutputs; // outputs
61 Vec_Int_t vOrder; // order
62 Vec_Int_t vSeq; // sequential objects
63 // stucture
64 Vec_Str_t vObjType; // type
65 Vec_Int_t vObjFin0; // fanins
66 Vec_Int_t vObjFon0; // outputs
67 Vec_Int_t vFinFon; // fons
68 Vec_Int_t vFonObj; // object
69 // optional
70 Vec_Int_t vObjCopy; // copy
71 Vec_Int_t vObjFunc; // function
72 Vec_Int_t vObjName; // name
73 Vec_Int_t vObjAttr; // attribute offset
74 Vec_Int_t vAttrSto; // attribute storage
75 Vec_Int_t vFonCopy; // copy
76 Vec_Int_t vFonName; // name
77 Vec_Int_t vFonRange;// range
78 Vec_Int_t vFonPrev; // fanout: prev fon
79 Vec_Int_t vFonNext; // fanout: next fon
80 Vec_Int_t vFinFon0; // fanout: first fon
81 Vec_Int_t vFinObj; // object
82 Vec_Int_t vNtkObjs; // instances
83 Vec_Int_t vFonBits; // fon mapping into AIG nodes
84 // other
85 Vec_Ptr_t * vOther; // various data
86 Vec_Int_t vArray0;
87 Vec_Int_t vArray1;
88};
89
90// design
91struct Cba_Man_t_
92{
93 // design names
94 char * pName; // design name
95 char * pSpec; // spec file name
96 Abc_Nam_t * pStrs; // string manager
97 Abc_Nam_t * pFuns; // constant manager
98 Abc_Nam_t * pMods; // module name manager
99 Hash_IntMan_t * vHash; // variable ranges
100 Vec_Int_t vNameMap; // mapping names
101 Vec_Int_t vNameMap2;// mapping names
102 Vec_Int_t vUsed; // used map entries
103 Vec_Int_t vUsed2; // used map entries
104 char * pTypeNames[CBA_BOX_LAST];
105 int nObjs[CBA_BOX_LAST]; // counter of objects of each type
106 int nAnds[CBA_BOX_LAST]; // counter of AND gates after blasting
107 // internal data
108 int iRoot; // root network
109 Vec_Ptr_t vNtks; // networks
110 // user data
111 int nOpens;
112 Vec_Str_t vOut;
113 Vec_Str_t vOut2;
114 void * pMioLib;
115};
116
120
121static inline char * Cba_ManName( Cba_Man_t * p ) { return p->pName; }
122static inline char * Cba_ManSpec( Cba_Man_t * p ) { return p->pSpec; }
123static inline int Cba_ManNtkNum( Cba_Man_t * p ) { return Vec_PtrSize(&p->vNtks)-1; }
124static inline int Cba_ManNtkIsOk( Cba_Man_t * p, int i ) { return i > 0 && i <= Cba_ManNtkNum(p); }
125static 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; }
126static inline int Cba_ManNtkFindId( Cba_Man_t * p, char * pName ) { return Abc_NamStrFind(p->pMods, pName); }
127static inline Cba_Ntk_t * Cba_ManNtkFind( Cba_Man_t * p, char * pName ) { return Cba_ManNtk( p, Cba_ManNtkFindId(p, pName) ); }
128static inline Cba_Ntk_t * Cba_ManRoot( Cba_Man_t * p ) { return Cba_ManNtk(p, p->iRoot); }
129static inline char * Cba_ManStr( Cba_Man_t * p, int i ) { return Abc_NamStr(p->pStrs, i); }
130static inline int Cba_ManStrId( Cba_Man_t * p, char * pStr ) { return Abc_NamStrFind(p->pStrs, pStr); }
131static inline int Cba_ManNameIdMax( Cba_Man_t * p ) { return Abc_NamObjNumMax(p->pStrs) + 1; }
132static inline char * Cba_ManConst( Cba_Man_t * p, int i ) { return Abc_NamStr(p->pFuns, i); }
133static inline int Cba_ManConstId( Cba_Man_t * p, char * pStr ) { return Abc_NamStrFind(p->pFuns, pStr); }
134static inline int Cba_ManConstIdMax( Cba_Man_t * p ) { return Abc_NamObjNumMax(p->pFuns) + 1; }
135
136static inline Cba_Man_t * Cba_NtkMan( Cba_Ntk_t * p ) { return p->pDesign; }
137static inline Cba_Ntk_t * Cba_NtkNtk( Cba_Ntk_t * p, int i ) { return Cba_ManNtk(p->pDesign, i); }
138static inline int Cba_NtkId( Cba_Ntk_t * p ) { return p->Id; }
139static inline int Cba_NtkPi( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInputs, i); }
140static inline int Cba_NtkPo( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vOutputs, i); }
141static inline int Cba_NtkPioOrder( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vOrder, i); }
142static inline int Cba_NtkBoxSeq( Cba_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vSeq, i); }
143static inline Abc_Nam_t * Cba_NtkNam( Cba_Ntk_t * p ) { return p->pDesign->pStrs; }
144static inline char * Cba_NtkStr( Cba_Ntk_t * p, int i ) { return Cba_ManStr(p->pDesign, i); }
145static inline int Cba_NtkStrId( Cba_Ntk_t * p, char * pName ) { return Cba_ManStrId(p->pDesign, pName); }
146static inline char * Cba_NtkConst( Cba_Ntk_t * p, int i ) { return Cba_ManConst(p->pDesign, i); }
147static inline char * Cba_NtkSop( Cba_Ntk_t * p, int i ) { return Cba_ManConst(p->pDesign, i); }
148static inline int Cba_NtkNameId( Cba_Ntk_t * p ) { return p->NameId; }
149static inline char * Cba_NtkName( Cba_Ntk_t * p ) { return Cba_NtkStr(p, p->NameId); }
150static inline char * Cba_NtkTypeName( Cba_Ntk_t * p, int Type ) { return p->pDesign->pTypeNames[Type]; }
151static inline int Cba_NtkCopy( Cba_Ntk_t * p ) { return p->iCopy; }
152static inline Cba_Ntk_t * Cba_NtkCopyNtk(Cba_Man_t * pNew, Cba_Ntk_t * p) { return Cba_ManNtk(pNew, Cba_NtkCopy(p)); }
153static inline void Cba_NtkSetCopy( Cba_Ntk_t * p, int i ) { assert(p->iCopy == 0); p->iCopy = i; }
154static inline int Cba_NtkHashRange( Cba_Ntk_t * p, int l, int r ) { return Hash_Int2ManInsert( p->pDesign->vHash, l, r, 0 ); }
155static inline int Cba_NtkRangeLeft( Cba_Ntk_t * p, int h ) { return h ? Hash_IntObjData0( p->pDesign->vHash, h ) : 0; }
156static inline int Cba_NtkRangeRight( Cba_Ntk_t * p, int h ) { return h ? Hash_IntObjData1( p->pDesign->vHash, h ) : 0; }
157static inline int Cba_NtkRangeSize( Cba_Ntk_t * p, int h ) { int l = Cba_NtkRangeLeft(p, h), r = Cba_NtkRangeRight(p, h); return 1 + (l > r ? l-r : r-l);}
158
159static inline int Cba_NtkPiNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vInputs); }
160static inline int Cba_NtkPoNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vOutputs); }
161static inline int Cba_NtkPioNum( Cba_Ntk_t * p ) { return Cba_NtkPiNum(p) + Cba_NtkPoNum(p); }
162static inline int Cba_NtkPiNumAlloc( Cba_Ntk_t * p ) { return Vec_IntCap(&p->vInputs); }
163static inline int Cba_NtkPoNumAlloc( Cba_Ntk_t * p ) { return Vec_IntCap(&p->vOutputs); }
164static inline int Cba_NtkPioOrderNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vOrder); }
165static inline int Cba_NtkObjNum( Cba_Ntk_t * p ) { return Vec_StrSize(&p->vObjType)-1; }
166static inline int Cba_NtkObjNumAlloc( Cba_Ntk_t * p ) { return Vec_StrCap(&p->vObjType)-1; }
167static inline int Cba_NtkFinNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFinFon)-1; }
168static inline int Cba_NtkFinNumAlloc( Cba_Ntk_t * p ) { return Vec_IntCap(&p->vFinFon)-1; }
169static inline int Cba_NtkFonNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFonObj)-1; }
170static inline int Cba_NtkFonNumAlloc( Cba_Ntk_t * p ) { return Vec_IntCap(&p->vFonObj)-1; }
171static inline int Cba_NtkTypeNum( Cba_Ntk_t * p, int Type ) { return Vec_StrCountEntry(&p->vObjType, (char)Type); }
172static inline int Cba_NtkBoxNum( Cba_Ntk_t * p ) { return Cba_NtkObjNum(p) - Cba_NtkPioNum(p); }
173static inline int Cba_NtkBoxUserNum( Cba_Ntk_t * p ) { return Cba_NtkTypeNum(p, CBA_OBJ_BOX); }
174static inline int Cba_NtkBoxPrimNum( Cba_Ntk_t * p ) { return Vec_StrCountLarger(&p->vObjType, (char)CBA_OBJ_BOX); }
175static inline int Cba_NtkBoxSeqNum( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vSeq); }
176
177static inline void Cba_NtkCleanObjCopies( Cba_Ntk_t * p ) { Vec_IntFill(&p->vObjCopy, Vec_StrCap(&p->vObjType), -1); }
178static inline void Cba_NtkCleanObjFuncs( Cba_Ntk_t * p ) { Vec_IntFill(&p->vObjFunc, Vec_StrCap(&p->vObjType), 0); }
179static inline void Cba_NtkCleanObjNames( Cba_Ntk_t * p ) { Vec_IntFill(&p->vObjName, Vec_StrCap(&p->vObjType), 0); }
180static inline void Cba_NtkCleanObjAttrs( Cba_Ntk_t * p ) { Vec_IntFill(&p->vObjAttr, Vec_StrCap(&p->vObjType), 0); Vec_IntFill(&p->vAttrSto, 1, -1); }
181static inline void Cba_NtkCleanFonCopies( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFonCopy, Vec_IntCap(&p->vFonObj), 0); }
182static inline void Cba_NtkCleanFonNames( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFonName, Vec_IntCap(&p->vFonObj), 0); }
183static inline void Cba_NtkCleanFonRanges( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFonRange, Vec_IntCap(&p->vFonObj), 0); }
184static inline void Cba_NtkCleanFonPrevs( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFonPrev, Vec_IntCap(&p->vFonObj), 0); }
185static inline void Cba_NtkCleanFonNexts( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFonNext, Vec_IntCap(&p->vFonObj), 0); }
186static inline void Cba_NtkCleanFinFon0( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFinFon0, Vec_IntCap(&p->vFinFon), 0); }
187static inline void Cba_NtkCleanFinObjs( Cba_Ntk_t * p ) { Vec_IntFill(&p->vFinObj, Vec_IntCap(&p->vFinFon), 0); }
188
189static inline int Cba_NtkHasObjCopies( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vObjCopy) > 0; }
190static inline int Cba_NtkHasObjFuncs( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vObjFunc) > 0; }
191static inline int Cba_NtkHasObjNames( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vObjName) > 0; }
192static inline int Cba_NtkHasObjAttrs( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vObjAttr) > 0; }
193static inline int Cba_NtkHasFonCopies( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFonCopy) > 0; }
194static inline int Cba_NtkHasFonNames( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFonName) > 0; }
195static inline int Cba_NtkHasFonRanges( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFonRange) > 0; }
196static inline int Cba_NtkHasFonPrevs( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFonPrev) > 0; }
197static inline int Cba_NtkHasFonNexts( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFonNext) > 0; }
198static inline int Cba_NtkHasFinFon0( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFinFon0) > 0; }
199static inline int Cba_NtkHasFinObjs( Cba_Ntk_t * p ) { return Vec_IntSize(&p->vFinObj) > 0; }
200
201static inline void Cba_NtkFreeObjCopies( Cba_Ntk_t * p ) { Vec_IntErase(&p->vObjCopy); }
202static inline void Cba_NtkFreeObjFuncs( Cba_Ntk_t * p ) { Vec_IntErase(&p->vObjFunc); }
203static inline void Cba_NtkFreeObjNames( Cba_Ntk_t * p ) { Vec_IntErase(&p->vObjName); }
204static inline void Cba_NtkFreeObjAttrs( Cba_Ntk_t * p ) { Vec_IntErase(&p->vObjAttr); }
205static inline void Cba_NtkFreeFonCopies( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFonCopy); }
206static inline void Cba_NtkFreeFonNames( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFonName); }
207static inline void Cba_NtkFreeFonRanges( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFonRange); }
208static inline void Cba_NtkFreeFonPrevs( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFonPrev); }
209static inline void Cba_NtkFreeFonNexts( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFonNext); }
210static inline void Cba_NtkFreeFinFon0( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFinFon0); }
211static inline void Cba_NtkFreeFinObjs( Cba_Ntk_t * p ) { Vec_IntErase(&p->vFinObj); }
212
213static 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); }
214static inline void Cba_ObjCleanType( Cba_Ntk_t * p, int i ) { assert(i>0); Vec_StrWriteEntry( &p->vObjType, i, (char)CBA_OBJ_NONE ); }
215static inline int Cba_TypeIsBox( Cba_ObjType_t Type ) { return Type >= CBA_OBJ_BOX && Type < CBA_BOX_LAST; }
216static inline int Cba_TypeIsSeq( Cba_ObjType_t Type ) { return Type >= CBA_BOX_RAM && Type <= CBA_BOX_DFFRS; }
217static inline int Cba_TypeIsUnary( Cba_ObjType_t Type ) { return Type == CBA_BOX_BUF || Type == CBA_BOX_INV || Type == CBA_BOX_LNOT || Type == CBA_BOX_MIN || Type == CBA_BOX_SQRT || Type == CBA_BOX_ABS || (Type >= CBA_BOX_RAND && Type <= CBA_BOX_RXNOR); }
218static inline int Cba_TypeIsMux( Cba_ObjType_t Type ) { return Type == CBA_BOX_MUX || Type == CBA_BOX_NMUX || Type == CBA_BOX_SEL || Type == CBA_BOX_PSEL; }
219
220static inline int Cba_ObjIsPi( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_PI; }
221static inline int Cba_ObjIsPo( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_PO; }
222static inline int Cba_ObjIsPio( Cba_Ntk_t * p, int i ) { return Cba_ObjIsPi(p, i) || Cba_ObjIsPo(p, i); }
223static inline int Cba_ObjIsBox( Cba_Ntk_t * p, int i ) { return Cba_TypeIsBox(Cba_ObjType(p, i)); }
224static inline int Cba_ObjIsBoxUser( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_OBJ_BOX; }
225static 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; }
226static inline int Cba_ObjIsGate( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_BOX_GATE; }
227static inline int Cba_ObjIsSlice( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_BOX_SLICE; }
228static inline int Cba_ObjIsConcat( Cba_Ntk_t * p, int i ) { return Cba_ObjType(p, i) == CBA_BOX_CONCAT; }
229static inline int Cba_ObjIsUnary( Cba_Ntk_t * p, int i ) { return Cba_TypeIsUnary(Cba_ObjType(p, i)); }
230
231static inline int Cba_ObjFin0( Cba_Ntk_t * p, int i ) { assert(i>0); return Vec_IntEntry(&p->vObjFin0, i); }
232static inline int Cba_ObjFon0( Cba_Ntk_t * p, int i ) { assert(i>0); return Vec_IntEntry(&p->vObjFon0, i); }
233static inline int Cba_ObjFin( Cba_Ntk_t * p, int i, int k ) { assert(i>0); return Cba_ObjFin0(p, i) + k; }
234static inline int Cba_ObjFon( Cba_Ntk_t * p, int i, int k ) { assert(i>0); return Cba_ObjFon0(p, i) + k; }
235static inline int Cba_ObjFinNum( Cba_Ntk_t * p, int i ) { assert(i>0); return Cba_ObjFin0(p, i+1) - Cba_ObjFin0(p, i); }
236static inline int Cba_ObjFonNum( Cba_Ntk_t * p, int i ) { assert(i>0); return Cba_ObjFon0(p, i+1) - Cba_ObjFon0(p, i); }
237
238static inline int Cba_ObjCopy( Cba_Ntk_t * p, int i ) { assert(i>0); assert( Cba_NtkHasObjCopies(p) ); return Vec_IntGetEntryFull(&p->vObjCopy, i); }
239static inline int Cba_ObjFunc( Cba_Ntk_t * p, int i ) { assert(i>0); assert( Cba_NtkHasObjFuncs(p) ); return Vec_IntGetEntry(&p->vObjFunc, i); }
240static inline int Cba_ObjName( Cba_Ntk_t * p, int i ) { assert(i>0); assert( Cba_NtkHasObjNames(p) ); return Vec_IntGetEntry(&p->vObjName, i); }
241static inline char * Cba_ObjNameStr( Cba_Ntk_t * p, int i ) { assert(i>0); return Cba_NtkStr(p, Cba_ObjName(p, i)); }
242static inline int Cba_ObjAttr( Cba_Ntk_t * p, int i ) { assert(i>=0); return Cba_NtkHasObjAttrs(p) ? Vec_IntGetEntry(&p->vObjAttr, i) : 0; }
243static inline int Cba_ObjAttrSize( Cba_Ntk_t * p, int i ) { assert(i>=0); return Cba_ObjAttr(p, i) ? Vec_IntEntry(&p->vAttrSto, Cba_ObjAttr(p, i)) : 0; }
244static inline int * Cba_ObjAttrArray( Cba_Ntk_t * p, int i ) { assert(i>=0); return Cba_ObjAttr(p, i) ? Vec_IntEntryP(&p->vAttrSto, Cba_ObjAttr(p, i)+1) : NULL; }
245static inline int Cba_ObjAttrValue( Cba_Ntk_t * p, int i, int x ) { int k, s = Cba_ObjAttrSize(p, i), * a = Cba_ObjAttrArray(p, i); for ( k = 0; k < s; k += 2) if (a[k] == x) return a[k+1]; return 0; }
246
247static inline void Cba_ObjSetCopy( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjCopy(p, i) == -1); Vec_IntSetEntry( &p->vObjCopy, i, x ); }
248static inline void Cba_ObjSetFunc( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjFunc(p, i) == 0); Vec_IntSetEntry( &p->vObjFunc, i, x ); }
249static inline void Cba_ObjSetName( Cba_Ntk_t * p, int i, int x ) { assert(Cba_ObjName(p, i) == 0); Vec_IntSetEntry( &p->vObjName, i, x ); }
250static inline void Cba_ObjSetAttrs( Cba_Ntk_t * p, int i, int * a, int s ) { assert(Cba_ObjAttr(p, i) == 0); if ( !a ) return; Vec_IntSetEntry(&p->vObjAttr, i, Vec_IntSize(&p->vAttrSto)); Vec_IntPush(&p->vAttrSto, s); Vec_IntPushArray(&p->vAttrSto, a, s); }
251
252static inline int Cba_FinFon( Cba_Ntk_t * p, int f ) { assert(f>0); return Vec_IntEntry(&p->vFinFon, f); }
253static inline void Cba_PatchFinFon( Cba_Ntk_t * p, int f, int x ) { assert(f>0); Vec_IntWriteEntry(&p->vFinFon, f, x); }
254static inline int Cba_ObjFinFon( Cba_Ntk_t * p, int i, int k ) { assert(i>0); return Cba_FinFon(p, Cba_ObjFin(p, i, k)); }
255static inline int * Cba_ObjFinFons( Cba_Ntk_t * p, int i ) { assert(i>0); return Vec_IntEntryP(&p->vFinFon, Cba_ObjFin0(p, i)); }
256
257static 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); }
258static 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); }
259static 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); }
260
261static inline int Cba_ObjNtkId( Cba_Ntk_t * p, int i ) { assert(i>0); return (Cba_ObjIsBoxUser(p, i) && Cba_NtkHasObjFuncs(p)) ? Cba_ObjFunc(p, i) : 0;}
262static inline Cba_Ntk_t * Cba_ObjNtk( Cba_Ntk_t * p, int i ) { assert(i>0); return Cba_NtkNtk(p, Cba_ObjNtkId(p, i)); }
263static inline void Cba_ObjSetNtkId( Cba_Ntk_t * p, int i, int x ) { assert(i>0); assert(Cba_ObjIsBoxUser(p, i)); Cba_ObjSetFunc( p, i, x ); }
264static inline int Cba_ObjIsSeq( Cba_Ntk_t * p, int i ) { assert(i>0); return Cba_ObjIsBoxUser(p, i) ? Cba_ObjNtk(p, i)->fSeq : Cba_TypeIsSeq(Cba_ObjType(p, i)); }
265
266static inline int Cba_FonIsReal( int f ) { return f > 0; }
267static inline int Cba_FonIsConst( int f ) { return f < 0; }
268static inline int Cba_FonConst( int f ) { assert(Cba_FonIsConst(f)); return -f-1; }
269static inline int Cba_FonFromConst( int c ) { assert(c >= 0); return -c-1; }
270static inline int Cba_FonConstRangeSize( Cba_Ntk_t * p, int f ) { assert(Cba_FonIsConst(f)); return atoi(Cba_NtkConst(p, Cba_FonConst(f))); }
271static inline int Cba_FonConstSigned( Cba_Ntk_t * p, int f ) { assert(Cba_FonIsConst(f)); return strchr(Cba_NtkConst(p, Cba_FonConst(f)), 's') != NULL; }
272
273static inline int Cba_FonObj( Cba_Ntk_t * p, int f ) { return Cba_FonIsReal(f) ? Vec_IntEntry(&p->vFonObj, f) : 0; }
274static inline int Cba_FonRangeId( Cba_Ntk_t * p, int f ) { assert(Cba_FonIsReal(f)); return Cba_NtkHasFonRanges(p)?Vec_IntGetEntry(&p->vFonRange, f):0;}
275static inline int Cba_FonRange( Cba_Ntk_t * p, int f ) { assert(Cba_FonIsReal(f)); return Abc_Lit2Var( Cba_FonRangeId(p, f) ); }
276static inline int Cba_FonLeft( Cba_Ntk_t * p, int f ) { return Cba_NtkRangeLeft(p, Cba_FonRange(p, f)); }
277static inline int Cba_FonRight( Cba_Ntk_t * p, int f ) { return Cba_NtkRangeRight(p, Cba_FonRange(p, f)); }
278static inline int Cba_FonSigned( Cba_Ntk_t * p, int f ) { return Cba_FonIsConst(f) ? Cba_FonConstSigned(p, f) : Abc_LitIsCompl(Cba_FonRangeId(p, f)); }
279static inline int Cba_FonRangeSize( Cba_Ntk_t * p, int f ) { return Cba_FonIsConst(f) ? Cba_FonConstRangeSize(p, f):Cba_NtkRangeSize(p, Cba_FonRange(p, f)); }
280static inline void Cba_FonSetRangeSign( Cba_Ntk_t * p, int f, int x ) { assert(Cba_NtkHasFonRanges(p)); Vec_IntSetEntry(&p->vFonRange, f, x); }
281static inline void Cba_FonSetRange( Cba_Ntk_t * p, int f, int x ) { assert(Cba_NtkHasFonRanges(p)); Vec_IntSetEntry(&p->vFonRange, f, Abc_Var2Lit(x,0)); }
282static inline void Cba_FonHashRange( Cba_Ntk_t * p, int f, int l, int r ) { Cba_FonSetRange( p, f, Cba_NtkHashRange(p, l, r) ); }
283static inline int Cba_FonCopy( Cba_Ntk_t * p, int f ) { return Cba_FonIsReal(f) ? Vec_IntEntry(&p->vFonCopy, f) : f; }
284static 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); }
285static inline int Cba_FonName( Cba_Ntk_t * p, int f ) { assert(Cba_NtkHasFonNames(p)); assert(Cba_FonIsReal(f)); return Vec_IntGetEntry( &p->vFonName, f ); }
286static inline char * Cba_FonNameStr( Cba_Ntk_t * p, int f ) { assert(Cba_NtkHasFonNames(p)); assert(Cba_FonIsReal(f)); return Cba_NtkStr(p, Cba_FonName(p, f)); }
287static inline void Cba_FonSetName( Cba_Ntk_t * p, int f, int x ) { assert(Cba_NtkHasFonNames(p)); assert(Cba_FonIsReal(f)); assert(Cba_FonName(p, f) == 0); Vec_IntSetEntry(&p->vFonName, f, x); }
288static inline void Cba_FonCleanName( Cba_Ntk_t * p, int f ) { assert(Cba_NtkHasFonNames(p)); assert(Cba_FonIsReal(f)); assert(Cba_FonName(p, f) != 0); Vec_IntSetEntry(&p->vFonName, f, 0); }
289static inline void Cba_FonPatchName( Cba_Ntk_t * p, int f, int x) { assert(Cba_NtkHasFonNames(p)); assert(Cba_FonIsReal(f)); Cba_FonCleanName(p, f); Cba_FonSetName(p, f, x); }
290static inline int Cba_FonIndex( Cba_Ntk_t * p, int f ) { assert(Cba_FonIsReal(f)); return f - Cba_ObjFon0( p, Cba_FonObj(p, f) ); }
291static inline int Cba_FonNtkId( Cba_Ntk_t * p, int f ) { assert(Cba_FonIsReal(f)); return Cba_ObjNtkId( p, Cba_FonObj(p, f) ); }
292static inline Cba_Ntk_t * Cba_FonNtk( Cba_Ntk_t * p, int f ) { assert(Cba_FonIsReal(f)); return Cba_ObjNtk( p, Cba_FonObj(p, f) ); }
293
294static inline int Cba_ObjFanin( Cba_Ntk_t * p, int i, int k ) { assert(i>0); return Cba_FonObj( p, Cba_ObjFinFon(p, i, k) ); }
295static inline int Cba_ObjLeft( Cba_Ntk_t * p, int i ) { return Cba_FonLeft( p, Cba_ObjFon0(p, i) ); }
296static inline int Cba_ObjRight( Cba_Ntk_t * p, int i ) { return Cba_FonRight( p, Cba_ObjFon0(p, i) ); }
297static inline int Cba_ObjRangeSize( Cba_Ntk_t * p, int i ) { return Cba_FonRangeSize( p, Cba_ObjFon0(p, i) ); }
298static inline int Cba_ObjSigned( Cba_Ntk_t * p, int i ) { return Cba_FonSigned( p, Cba_ObjFon0(p, i) ); }
299static inline int Cba_ObjSign( Cba_Ntk_t * p, int i ) { return Abc_Var2Lit( Cba_FonRangeSize(p, i), Cba_ObjSigned(p, i) ); }
300
304
305#define Cba_ManForEachNtk( p, pNtk, i ) \
306 for ( i = 1; (i <= Cba_ManNtkNum(p)) && (((pNtk) = Cba_ManNtk(p, i)), 1); i++ )
307
308#define Cba_NtkForEachPi( p, iObj, i ) \
309 for ( i = 0; (i < Cba_NtkPiNum(p)) && (((iObj) = Cba_NtkPi(p, i)), 1); i++ )
310#define Cba_NtkForEachPo( p, iObj, i ) \
311 for ( i = 0; (i < Cba_NtkPoNum(p)) && (((iObj) = Cba_NtkPo(p, i)), 1); i++ )
312#define Cba_NtkForEachBoxSeq( p, iObj, i ) \
313 for ( i = 0; (i < Cba_NtkBoxSeqNum(p)) && (((iObj) = Cba_NtkBoxSeq(p, i)), 1); i++ )
314#define Cba_NtkForEachPioOrder( p, iObj, i ) \
315 for ( i = 0; (i < Cba_NtkPioOrderNum(p)) && (((iObj) = Cba_NtkPioOrder(p, i)), 1); i++ )
316
317#define Cba_NtkForEachPiFon( p, iObj, iFon, i ) \
318 for ( i = 0; (i < Cba_NtkPiNum(p)) && (((iObj) = Cba_NtkPi(p, i)), 1) && (((iFon) = Cba_ObjFon0(p, iObj)), 1); i++ )
319#define Cba_NtkForEachPoDriverFon( p, iObj, iFon, i ) \
320 for ( i = 0; (i < Cba_NtkPoNum(p)) && (((iObj) = Cba_NtkPo(p, i)), 1) && (((iFon) = Cba_ObjFinFon(p, iObj, 0)), 1); i++ )
321#define Cba_NtkForEachPoDriver( p, iObj, i ) \
322 for ( i = 0; (i < Cba_NtkPoNum(p)) && (((iObj) = Cba_ObjFanin(p, Cba_NtkPo(p, i), 0)), 1); i++ )
323
324#define Cba_NtkForEachObj( p, i ) \
325 for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Cba_ObjType(p, i) ) {} else
326#define Cba_NtkForEachObjType( p, Type, i ) \
327 for ( i = 1; i < Vec_StrSize(&p->vObjType) && (((Type) = Cba_ObjType(p, i)), 1); i++ ) if ( !Type ) {} else
328#define Cba_NtkForEachBox( p, i ) \
329 for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Cba_ObjIsBox(p, i) ) {} else
330#define Cba_NtkForEachBoxComb( p, i ) \
331 for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Cba_ObjIsBox(p, i) || Cba_ObjIsSeq(p, i) ) {} else
332#define Cba_NtkForEachBoxUser( p, i ) \
333 for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Cba_ObjIsBoxUser(p, i) ) {} else
334#define Cba_NtkForEachBoxPrim( p, i ) \
335 for ( i = 1; i < Vec_StrSize(&p->vObjType); i++ ) if ( !Cba_ObjIsBoxPrim(p, i) ) {} else
336
337#define Cba_NtkForEachFon( p, i ) \
338 for ( i = 1; i < Vec_IntSize(&p->vFonObj); i++ )
339#define Cba_NtkForEachFinFon( p, iFon, iFin ) \
340 for ( iFin = 1; iFin < Vec_IntSize(&p->vFinFon) && (((iFon) = Vec_IntEntry(&p->vFinFon, iFin)), 1); iFin++ ) if ( !iFon ) {} else
341#define Cba_NtkForEachFonName( p, NameId, iFon ) \
342 for ( iFon = 1; iFon < Vec_IntSize(&p->vFonName) && (((NameId) = Vec_IntEntry(&p->vFonName, iFon)), 1); iFon++ ) if ( !NameId ) {} else
343
344#define Cba_ObjForEachFin( p, iObj, iFin, k ) \
345 for ( k = 0, iFin = Cba_ObjFin0(p, iObj); iFin < Cba_ObjFin0(p, iObj+1); iFin++, k++ )
346#define Cba_ObjForEachFon( p, iObj, iFon, k ) \
347 for ( k = 0, iFon = Cba_ObjFon0(p, iObj); iFon < Cba_ObjFon0(p, iObj+1); iFon++, k++ )
348#define Cba_ObjForEachFinFon( p, iObj, iFin, iFon, k ) \
349 for ( k = 0, iFin = Cba_ObjFin0(p, iObj); iFin < Cba_ObjFin0(p, iObj+1) && ((iFon = Cba_FinFon(p, iFin)), 1); iFin++, k++ )
350#define Cba_ObjForEachFinFanin( p, iObj, iFin, iFanin, k ) \
351 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++ )
352#define Cba_ObjForEachFinFaninReal( p, iObj, iFin, iFanin, k ) \
353 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
354
355
359
371static inline int Cba_ObjAlloc( Cba_Ntk_t * p, Cba_ObjType_t Type, int nFins, int nFons )
372{
373 int i, iObj = Vec_StrSize(&p->vObjType);
374 if ( Type == CBA_OBJ_PI )
375 Vec_IntPush( &p->vInputs, iObj );
376 else if ( Type == CBA_OBJ_PO )
377 Vec_IntPush( &p->vOutputs, iObj );
378 Vec_StrPush( &p->vObjType, (char)Type );
379 // add fins
380 for ( i = 0; i < nFins; i++ )
381 Vec_IntPush( &p->vFinFon, 0 );
382 if ( Vec_IntSize(&p->vObjFin0) )
383 Vec_IntPush( &p->vObjFin0, Vec_IntSize(&p->vFinFon) );
384 // add fons
385 for ( i = 0; i < nFons; i++ )
386 Vec_IntPush( &p->vFonObj, iObj );
387 if ( Vec_IntSize(&p->vObjFon0) )
388 Vec_IntPush( &p->vObjFon0, Vec_IntSize(&p->vFonObj) );
389 return iObj;
390}
391static inline int Cba_ObjDup( Cba_Ntk_t * pNew, Cba_Ntk_t * p, int i )
392{
393 int iObj = Cba_ObjAlloc( pNew, Cba_ObjType(p, i), Cba_ObjFinNum(p, i), Cba_ObjFonNum(p, i) );
394 Cba_ObjSetCopy( p, i, iObj );
395 return iObj;
396}
397static inline void Cba_ObjDelete( Cba_Ntk_t * p, int i )
398{
399 int k, iFin, iFon;
400 Cba_ObjCleanType( p, i );
401 Cba_ObjForEachFin( p, i, iFin, k )
402 Vec_IntWriteEntry( &p->vFinFon, iFin, 0 );
403 Cba_ObjForEachFon( p, i, iFon, k )
404 Vec_IntWriteEntry( &p->vFonObj, iFon, 0 );
405}
406
418static inline Cba_Ntk_t * Cba_NtkAlloc( Cba_Man_t * p, int NameId, int nIns, int nOuts, int nObjs, int nFins, int nFons )
419{
420 Cba_Ntk_t * pNew = ABC_CALLOC( Cba_Ntk_t, 1 );
421 assert( nIns >= 0 && nOuts >= 0 && nObjs >= 0 && nFins >= 0 && nFons >= 0 );
422 pNew->Id = Vec_PtrSize(&p->vNtks); Vec_PtrPush( &p->vNtks, pNew );
423 pNew->NameId = NameId;
424 pNew->pDesign = p;
425 Vec_IntGrow( &pNew->vInputs, nIns );
426 Vec_IntGrow( &pNew->vOutputs, nOuts );
427 Vec_StrGrow( &pNew->vObjType, nObjs+1 ); Vec_StrPush( &pNew->vObjType, (char)CBA_OBJ_NONE );
428 Vec_IntGrow( &pNew->vObjFin0, nObjs+2 ); Vec_IntPush( &pNew->vObjFin0, 0 ); Vec_IntPush( &pNew->vObjFin0, 1 );
429 Vec_IntGrow( &pNew->vObjFon0, nObjs+2 ); Vec_IntPush( &pNew->vObjFon0, 0 ); Vec_IntPush( &pNew->vObjFon0, 1 );
430 Vec_IntGrow( &pNew->vFinFon, nFins+1 ); Vec_IntPush( &pNew->vFinFon, 0 );
431 Vec_IntGrow( &pNew->vFonObj, nFons+1 ); Vec_IntPush( &pNew->vFonObj, 0 );
432 return pNew;
433}
434static inline void Cba_NtkFree( Cba_Ntk_t * p )
435{
436 // interface
437 Vec_IntErase( &p->vInputs );
438 Vec_IntErase( &p->vOutputs );
439 Vec_IntErase( &p->vOrder );
440 Vec_IntErase( &p->vSeq );
441 // stucture
442 Vec_StrErase( &p->vObjType );
443 Vec_IntErase( &p->vObjFin0 );
444 Vec_IntErase( &p->vObjFon0 );
445 Vec_IntErase( &p->vFinFon );
446 Vec_IntErase( &p->vFonObj );
447 // optional
448 Vec_IntErase( &p->vObjCopy );
449 Vec_IntErase( &p->vObjFunc );
450 Vec_IntErase( &p->vObjName );
451 Vec_IntErase( &p->vObjAttr );
452 Vec_IntErase( &p->vAttrSto );
453 Vec_IntErase( &p->vFonCopy );
454 Vec_IntErase( &p->vFonName );
455 Vec_IntErase( &p->vFonRange );
456 Vec_IntErase( &p->vFonPrev );
457 Vec_IntErase( &p->vFonNext );
458 Vec_IntErase( &p->vFinFon0 );
459 Vec_IntErase( &p->vFinObj );
460 Vec_IntErase( &p->vNtkObjs );
461 Vec_IntErase( &p->vFonBits );
462 // other
463 Vec_IntErase( &p->vArray0 );
464 Vec_IntErase( &p->vArray1 );
465 if ( p->vOther ) Vec_VecFree( (Vec_Vec_t *)p->vOther );
466 ABC_FREE( p );
467}
468static inline int Cba_NtkNewStrId( Cba_Ntk_t * pNtk, const char * format, ... )
469{
470 Abc_Nam_t * p = Cba_NtkNam( pNtk );
471 Vec_Str_t * vBuf = Abc_NamBuffer( p );
472 int nAdded, nSize = 1000;
473 va_list args; va_start( args, format );
474 Vec_StrGrow( vBuf, Vec_StrSize(vBuf) + nSize );
475 nAdded = vsnprintf( Vec_StrLimit(vBuf), nSize, format, args );
476 if ( nAdded > nSize )
477 {
478 Vec_StrGrow( vBuf, Vec_StrSize(vBuf) + nAdded + nSize );
479 nSize = vsnprintf( Vec_StrLimit(vBuf), nAdded, format, args );
480 assert( nSize == nAdded );
481 }
482 va_end( args );
483 return Abc_NamStrFindOrAddLim( p, Vec_StrLimit(vBuf), Vec_StrLimit(vBuf) + nAdded, NULL );
484}
485static inline int Cba_ManNewConstId( Cba_Ntk_t * p, Vec_Str_t * vBits )
486{
487 Vec_Str_t * vOut = Abc_NamBuffer(Cba_NtkNam(p));
488 Vec_StrPrintF( vOut, "%d\'b%s", Vec_StrSize(vBits)-1, Vec_StrArray(vBits) );
489 return Abc_NamStrFindOrAdd(p->pDesign->pFuns, Vec_StrArray(vOut), NULL);
490}
491static inline int Cba_ManNewConstZero( Cba_Ntk_t * p, int nBits )
492{
493 Vec_Str_t * vOut = Abc_NamBuffer(Cba_NtkNam(p));
494 Vec_StrPrintF( vOut, "%d\'b%0s", nBits, "" );
495 return Abc_NamStrFindOrAdd(p->pDesign->pFuns, Vec_StrArray(vOut), NULL);
496}
497static inline void Cba_NtkAdd( Cba_Man_t * p, Cba_Ntk_t * pNtk )
498{
499 int fFound, NtkId = Abc_NamStrFindOrAdd( p->pMods, Cba_NtkName(pNtk), &fFound );
500 if ( fFound )
501 printf( "Network with name \"%s\" already exists.\n", Cba_NtkName(pNtk) );
502 else
503 assert( NtkId == pNtk->Id );
504}
505static inline void Cba_NtkUpdate( Cba_Man_t * p, Cba_Ntk_t * pNtk )
506{
507 int fFound, NtkId = Abc_NamStrFindOrAdd( p->pMods, Cba_NtkName(pNtk), &fFound );
508 if ( !fFound )
509 printf( "Network with name \"%s\" does not exist.\n", Cba_NtkName(pNtk) );
510 else
511 {
512 Cba_NtkFree( Cba_ManNtk(p, NtkId) );
513 Vec_PtrWriteEntry( &p->vNtks, NtkId, pNtk );
514 }
515}
516static inline Vec_Int_t * Cba_NtkCollect( Cba_Ntk_t * p )
517{
518 int iObj;
519 Vec_Int_t * vObjs = Vec_IntAlloc( Cba_NtkObjNum(p) );
520 Cba_NtkForEachObj( p, iObj )
521 Vec_IntPush( vObjs, iObj );
522 return vObjs;
523}
524static inline int Cba_NtkIsSeq( Cba_Ntk_t * p )
525{
526 int iObj;
527 if ( p->fSeq )
528 return 1;
529 if ( p->fComb )
530 return 0;
531 assert( !p->fSeq && !p->fComb );
532 Cba_NtkForEachBox( p, iObj )
533 if ( Cba_ObjIsBoxUser(p, iObj) )
534 {
535 if ( Cba_NtkIsSeq( Cba_ObjNtk(p, iObj) ) )
536 {
537 p->fSeq = 1;
538 return 1;
539 }
540 }
541 else if ( Cba_ObjIsSeq(p, iObj) )
542 {
543 p->fSeq = 1;
544 return 1;
545 }
546 p->fComb = 1;
547 return 0;
548}
549static inline void Cba_NtkPrepareSeq( Cba_Ntk_t * p )
550{
551 int iObj;
552 assert( Cba_NtkBoxSeqNum(p) == 0 );
553 if ( !Cba_NtkIsSeq(p) )
554 return;
555 Cba_NtkForEachBox( p, iObj )
556 if ( Cba_ObjIsSeq(p, iObj) )
557 Vec_IntPush( &p->vSeq, iObj );
558 // Cba_NtkObjOrder( p, &p->vSeq, NULL );
559}
560static inline void Cba_NtkCountParams( Cba_Ntk_t * p, Vec_Int_t * vObjs, int * nPis, int * nPos, int * nFins, int * nFons )
561{
562 int i, iObj;
563 *nPis = *nPos = *nFins = *nFons = 0;
564 Vec_IntForEachEntry( vObjs, iObj, i )
565 {
566 *nPis += Cba_ObjIsPi(p, iObj);
567 *nPos += Cba_ObjIsPo(p, iObj);
568 *nFins += Cba_ObjFinNum(p, iObj);
569 *nFons += Cba_ObjFonNum(p, iObj);
570 }
571}
572static inline Cba_Ntk_t * Cba_NtkDup( Cba_Man_t * pMan, Cba_Ntk_t * p, Vec_Int_t * vObjs )
573{
574 Cba_Ntk_t * pNew;
575 int i, k, iObj, iObjNew, iFin, iFon;
576 int nPis, nPos, nFins, nFons;
577 Cba_NtkCountParams( p, vObjs, &nPis, &nPos, &nFins, &nFons );
578 pNew = Cba_NtkAlloc( pMan, Cba_NtkNameId(p), nPis, nPos, Vec_IntSize(vObjs), nFins, nFons );
579 Cba_NtkCleanObjCopies( p );
580 Cba_NtkCleanFonCopies( p );
581 Vec_IntForEachEntry( vObjs, iObj, i )
582 {
583 iObjNew = Cba_ObjDup( pNew, p, iObj );
584 Cba_ObjForEachFon( p, iObj, iFon, k )
585 Cba_FonSetCopy( p, iFon, Cba_ObjFon(pNew, iObjNew, k) );
586 }
587 Vec_IntForEachEntry( vObjs, iObj, i )
588 {
589 iObjNew = Cba_ObjCopy( p, iObj );
590 Cba_ObjForEachFinFon( p, iObj, iFin, iFon, k )
591 Cba_ObjSetFinFon( pNew, iObjNew, k, Cba_FonCopy(p, iFon) );
592 }
593 //Cba_NtkFreeObjCopies( p );
594 //Cba_NtkFreeFonCopies( p );
595 assert( Cba_NtkObjNum(pNew) == Cba_NtkObjNumAlloc(pNew) );
596 Cba_NtkSetCopy( p, Cba_NtkId(pNew) );
597 return pNew;
598}
599static inline Cba_Ntk_t * Cba_NtkDupOrder( Cba_Man_t * pMan, Cba_Ntk_t * p, Vec_Int_t*(* pFuncOrder)(Cba_Ntk_t*) )
600{
601 Cba_Ntk_t * pNew;
602 Vec_Int_t * vObjs = pFuncOrder ? pFuncOrder(p) : Cba_NtkCollect(p);
603 if ( vObjs == NULL )
604 return NULL;
605 pNew = Cba_NtkDup( pMan, p, vObjs );
606 Vec_IntFree( vObjs );
607 //Cba_NtkPrepareSeq( pNew );
608 return pNew;
609}
610static inline void Cba_NtkDupAttrs( Cba_Ntk_t * pNew, Cba_Ntk_t * p )
611{
612 int i, iObj;
613 assert( Vec_IntSize(&pNew->vOrder) == 0 );
614 Cba_NtkForEachPioOrder( p, iObj, i )
615 Vec_IntPush( &pNew->vOrder, Cba_ObjCopy(p, iObj) );
616// Vec_IntRemapArray( &p->vObjCopy, &p->vOrder, &pNew->vOrder, Cba_NtkPioOrderNum(p) );
617// Vec_IntRemapArray( &p->vObjCopy, &p->vSeq, &pNew->vSeq, Cba_NtkBoxSeqNum(p) );
618 // transfer object attributes
619 Vec_IntRemapArray( &p->vObjCopy, &p->vObjFunc, &pNew->vObjFunc, Cba_NtkObjNum(pNew) + 1 );
620 Vec_IntRemapArray( &p->vObjCopy, &p->vObjName, &pNew->vObjName, Cba_NtkObjNum(pNew) + 1 );
621 Vec_IntRemapArray( &p->vObjCopy, &p->vObjAttr, &pNew->vObjAttr, Cba_NtkObjNum(pNew) + 1 );
622 // transfer fon attributes
623 Vec_IntRemapArray( &p->vFonCopy, &p->vFonName, &pNew->vFonName, Cba_NtkFonNum(pNew) + 1 );
624 Vec_IntRemapArray( &p->vFonCopy, &p->vFonRange, &pNew->vFonRange, Cba_NtkFonNum(pNew) + 1 );
625 // duplicate attributes
626 Vec_IntAppend( &pNew->vAttrSto, &p->vAttrSto );
627 pNew->vOther = p->vOther ? (Vec_Ptr_t *)Vec_VecDup( (Vec_Vec_t *)p->vOther ) : NULL;
628}
629static inline int Cba_NtkMemory( Cba_Ntk_t * p )
630{
631 int nMem = sizeof(Cba_Ntk_t);
632 // interface
633 nMem += (int)Vec_IntMemory(&p->vInputs);
634 nMem += (int)Vec_IntMemory(&p->vOutputs);
635 nMem += (int)Vec_IntMemory(&p->vOrder);
636 nMem += (int)Vec_IntMemory(&p->vSeq);
637 // stucture
638 nMem += (int)Vec_StrMemory(&p->vObjType);
639 nMem += (int)Vec_IntMemory(&p->vObjFin0);
640 nMem += (int)Vec_IntMemory(&p->vObjFon0);
641 nMem += (int)Vec_IntMemory(&p->vFinFon);
642 nMem += (int)Vec_IntMemory(&p->vFonObj);
643 // optional
644 nMem += (int)Vec_IntMemory(&p->vObjCopy );
645 nMem += (int)Vec_IntMemory(&p->vObjFunc );
646 nMem += (int)Vec_IntMemory(&p->vObjName );
647 nMem += (int)Vec_IntMemory(&p->vObjAttr );
648 nMem += (int)Vec_IntMemory(&p->vAttrSto );
649 nMem += (int)Vec_IntMemory(&p->vFonCopy );
650 nMem += (int)Vec_IntMemory(&p->vFonName );
651 nMem += (int)Vec_IntMemory(&p->vFonRange );
652 nMem += (int)Vec_IntMemory(&p->vFonPrev );
653 nMem += (int)Vec_IntMemory(&p->vFonNext );
654 nMem += (int)Vec_IntMemory(&p->vFinFon0 );
655 nMem += (int)Vec_IntMemory(&p->vFinObj );
656 nMem += (int)Vec_IntMemory(&p->vNtkObjs );
657 nMem += (int)Vec_IntMemory(&p->vFonBits );
658 // other
659 nMem += (int)Vec_IntMemory(&p->vArray1 );
660 nMem += (int)Vec_IntMemory(&p->vArray1 );
661 return nMem;
662}
663static inline void Cba_NtkPrintStats( Cba_Ntk_t * p )
664{
665 printf( "pi =%5d ", Cba_NtkPiNum(p) );
666 printf( "po =%5d ", Cba_NtkPoNum(p) );
667 printf( "seq =%5d ", Cba_NtkBoxSeqNum(p) );
668 printf( "box =%5d ", Cba_NtkBoxNum(p) );
669 printf( "prim =%5d ", Cba_NtkBoxPrimNum(p) );
670 printf( "user =%5d ", Cba_NtkBoxUserNum(p) );
671 //printf( "topo =%4s ", Cba_NtkIsTopoOrder(p) ? "yes" : "no" );
672 printf( " %s ", Cba_NtkName(p) );
673 if ( Vec_IntSize(&p->vNtkObjs) )
674 printf( "-> %s", Cba_NtkName(Cba_NtkNtk(p, Vec_IntEntry(&p->vNtkObjs, 0))) );
675 printf( "\n" );
676// Vec_StrIntPrint( &p->vObjType );
677}
678static inline void Cba_NtkPrint( Cba_Ntk_t * p )
679{
680 int i, Type;
681 printf( "Interface (%d):\n", Cba_NtkPioNum(p) );
682 printf( "Objects (%d):\n", Cba_NtkObjNum(p) );
683 Cba_NtkForEachObjType( p, Type, i )
684 {
685 printf( "%6d : ", i );
686 printf( "Type =%3d ", Type );
687 printf( "Fins = %d ", Cba_ObjFinNum(p, i) );
688 printf( "Fons = %d ", Cba_ObjFonNum(p, i) );
689 if ( Cba_NtkHasObjNames(p) && Cba_ObjName(p, i) )
690 printf( "%s", Cba_ObjNameStr(p, i) );
691 printf( "\n" );
692 }
693}
694
706static inline Cba_Man_t * Cba_ManAlloc( char * pFileName, int nNtks, Abc_Nam_t * pStrs, Abc_Nam_t * pFuns, Abc_Nam_t * pMods, Hash_IntMan_t * vHash )
707{
708 Cba_Man_t * pNew = ABC_CALLOC( Cba_Man_t, 1 );
709 pNew->pName = Extra_FileDesignName( pFileName );
710 pNew->pSpec = Abc_UtilStrsav( pFileName );
711 pNew->pStrs = pStrs ? pStrs : Abc_NamStart( 1000, 24 );
712 pNew->pFuns = pFuns ? pFuns : Abc_NamStart( 100, 24 );
713 pNew->pMods = pMods ? pMods : Abc_NamStart( 100, 24 );
714 pNew->vHash = vHash ? vHash : Hash_IntManStart( 1000 );
715 if ( pFuns == NULL )
716 {
717 Abc_NamStrFindOrAdd(pNew->pFuns, "1\'b0", NULL);
718 Abc_NamStrFindOrAdd(pNew->pFuns, "1\'b1", NULL);
719 Abc_NamStrFindOrAdd(pNew->pFuns, "1\'bx", NULL);
720 Abc_NamStrFindOrAdd(pNew->pFuns, "1\'bz", NULL);
721 }
722// if ( vHash == NULL )
723// Hash_Int2ManInsert( pNew->vHash, 0, 0, 0 );
724 Vec_PtrGrow( &pNew->vNtks, nNtks+1 ); Vec_PtrPush( &pNew->vNtks, NULL );
725 // set default root module
726 pNew->iRoot = 1;
727 return pNew;
728}
729static inline void Cba_ManDupTypeNames( Cba_Man_t * pNew, Cba_Man_t * p )
730{
731 memcpy( pNew->pTypeNames, p->pTypeNames, sizeof(void *) * CBA_BOX_LAST );
732}
733static inline Cba_Man_t * Cba_ManDup( Cba_Man_t * p, Vec_Int_t*(* pFuncOrder)(Cba_Ntk_t*) )
734{
735 Cba_Ntk_t * pNtk, * pNtkNew; int i;
736 Cba_Man_t * pNew = Cba_ManAlloc( p->pSpec, Cba_ManNtkNum(p), Abc_NamRef(p->pStrs), Abc_NamRef(p->pFuns), Abc_NamStart(100, 24), Hash_IntManRef(p->vHash) );
737 Cba_ManDupTypeNames( pNew, p );
738 Cba_ManForEachNtk( p, pNtk, i )
739 {
740 pNtkNew = Cba_NtkDupOrder( pNew, pNtk, pFuncOrder );
741 Cba_NtkAdd( pNew, pNtkNew );
742 Cba_NtkDupAttrs( pNtkNew, pNtk );
743 }
744// Cba_ManForEachNtk( p, pNtk, i )
745// if ( (pHost = Cba_NtkHostNtk(pNtk)) )
746// Cba_NtkSetHost( Cba_NtkCopyNtk(pNew, pNtk), Cba_NtkCopy(pHost), Cba_ObjCopy(pHost, Cba_NtkHostObj(pNtk)) );
747 pNew->iRoot = Cba_ManNtkNum(pNew);
748 return pNew;
749}
750static inline void Cba_ManPrepareSeq( Cba_Man_t * p )
751{
752 Cba_Ntk_t * pNtk; int i;
753 Cba_ManForEachNtk( p, pNtk, i )
754 Cba_NtkPrepareSeq( pNtk );
755}
756static inline void Cba_ManFree( Cba_Man_t * p )
757{
758 Cba_Ntk_t * pNtk; int i;
759 Cba_ManForEachNtk( p, pNtk, i )
760 Cba_NtkFree( pNtk );
761 ABC_FREE( p->vNtks.pArray );
762 Abc_NamDeref( p->pStrs );
763 Abc_NamDeref( p->pFuns );
764 Abc_NamDeref( p->pMods );
765 Hash_IntManDeref( p->vHash );
766 Vec_IntErase( &p->vNameMap );
767 Vec_IntErase( &p->vUsed );
768 Vec_IntErase( &p->vNameMap2 );
769 Vec_IntErase( &p->vUsed2 );
770 Vec_StrErase( &p->vOut );
771 Vec_StrErase( &p->vOut2 );
772 ABC_FREE( p->pName );
773 ABC_FREE( p->pSpec );
774 ABC_FREE( p );
775}
776static inline int Cba_ManGetMap( Cba_Man_t * p, int i )
777{
778 return Vec_IntGetEntry(&p->vNameMap, i);
779}
780static inline void Cba_ManSetMap( Cba_Man_t * p, int i, int x )
781{
782 assert( Vec_IntGetEntry(&p->vNameMap, i) == 0 );
783 Vec_IntSetEntry( &p->vNameMap, i, x );
784 Vec_IntPush( &p->vUsed, i );
785}
786static inline void Cba_ManUnsetMap( Cba_Man_t * p, int i )
787{
788 Vec_IntSetEntry( &p->vNameMap, i, 0 );
789}
790static inline void Cba_ManCleanMap( Cba_Man_t * p )
791{
792 int i, Entry;
793 Vec_IntForEachEntry( &p->vUsed, Entry, i )
794 Vec_IntWriteEntry( &p->vNameMap, Entry, 0 );
795 Vec_IntClear( &p->vUsed );
796}
797static inline int Cba_NtkGetMap( Cba_Ntk_t * p, int i ) { return Cba_ManGetMap(p->pDesign, i); }
798static inline void Cba_NtkSetMap( Cba_Ntk_t * p, int i, int x ) { Cba_ManSetMap(p->pDesign, i, x); }
799static inline void Cba_NtkUnsetMap( Cba_Ntk_t * p, int i ) { Cba_ManUnsetMap(p->pDesign, i); }
800static inline void Cba_NtkCleanMap( Cba_Ntk_t * p ) { Cba_ManCleanMap(p->pDesign); }
801
802static inline int Cba_ManGetMap2( Cba_Man_t * p, int i )
803{
804 return Vec_IntGetEntry(&p->vNameMap2, i);
805}
806static inline void Cba_ManSetMap2( Cba_Man_t * p, int i, int x )
807{
808 assert( Vec_IntGetEntry(&p->vNameMap2, i) == 0 );
809 Vec_IntSetEntry( &p->vNameMap2, i, x );
810 Vec_IntPush( &p->vUsed2, i );
811}
812static inline void Cba_ManUnsetMap2( Cba_Man_t * p, int i )
813{
814 Vec_IntSetEntry( &p->vNameMap2, i, 0 );
815}
816static inline void Cba_ManCleanMap2( Cba_Man_t * p )
817{
818 int i, Entry;
819 Vec_IntForEachEntry( &p->vUsed2, Entry, i )
820 Vec_IntWriteEntry( &p->vNameMap2, Entry, 0 );
821 Vec_IntClear( &p->vUsed2 );
822}
823static inline int Cba_NtkGetMap2( Cba_Ntk_t * p, int i ) { return Cba_ManGetMap2(p->pDesign, i); }
824static inline void Cba_NtkSetMap2( Cba_Ntk_t * p, int i, int x ) { Cba_ManSetMap2(p->pDesign, i, x); }
825static inline void Cba_NtkUnsetMap2( Cba_Ntk_t * p, int i ) { Cba_ManUnsetMap2(p->pDesign, i); }
826static inline void Cba_NtkCleanMap2( Cba_Ntk_t * p ) { Cba_ManCleanMap2(p->pDesign); }
827
828static inline int Cba_ManMemory( Cba_Man_t * p )
829{
830 Cba_Ntk_t * pNtk; int i;
831 int nMem = sizeof(Cba_Man_t);
832 nMem += p->pName ? (int)strlen(p->pName) : 0;
833 nMem += p->pSpec ? (int)strlen(p->pSpec) : 0;
834 nMem += Abc_NamMemUsed(p->pStrs);
835 nMem += Abc_NamMemUsed(p->pFuns);
836 nMem += Abc_NamMemUsed(p->pMods);
837 nMem += (int)Vec_IntMemory(&p->vNameMap );
838 nMem += (int)Vec_IntMemory(&p->vUsed );
839 nMem += (int)Vec_StrMemory(&p->vOut );
840 nMem += (int)Vec_StrMemory(&p->vOut2 );
841 nMem += (int)Vec_PtrMemory(&p->vNtks);
842 Cba_ManForEachNtk( p, pNtk, i )
843 nMem += Cba_NtkMemory( pNtk );
844 return nMem;
845}
846static inline int Cba_ManObjNum( Cba_Man_t * p )
847{
848 Cba_Ntk_t * pNtk; int i, Count = 0;
849 Cba_ManForEachNtk( p, pNtk, i )
850 Count += Cba_NtkObjNum(pNtk);
851 return Count;
852}
853static inline int Cba_ManBoxNum( Cba_Man_t * p )
854{
855 Cba_Ntk_t * pNtk; int i, Count = 0;
856 Cba_ManForEachNtk( p, pNtk, i )
857 Count += Cba_NtkBoxNum( pNtk );
858 return Count;
859}
860static inline void Cba_ManBoxNumRec_rec( Cba_Ntk_t * p, int * pCountP, int * pCountU )
861{
862 int iObj, Id = Cba_NtkId(p);
863 if ( pCountP[Id] >= 0 )
864 return;
865 pCountP[Id] = pCountU[Id] = 0;
866 Cba_NtkForEachObj( p, iObj )
867 {
868 if ( Cba_ObjIsBoxUser(p, iObj) )
869 {
870 Cba_ManBoxNumRec_rec( Cba_ObjNtk(p, iObj), pCountP, pCountU );
871 pCountP[Id] += pCountP[Cba_ObjNtkId(p, iObj)];
872 pCountU[Id] += pCountU[Cba_ObjNtkId(p, iObj)] + 1;
873 }
874 else
875 pCountP[Id] += 1;
876 }
877}
878static inline void Cba_ManBoxNumRec( Cba_Man_t * p, int * pnPrims, int * pnUsers )
879{
880 Cba_Ntk_t * pNtk = Cba_ManRoot(p);
881 int * pCountP = ABC_FALLOC( int, Cba_ManNtkNum(p) + 1 );
882 int * pCountU = ABC_FALLOC( int, Cba_ManNtkNum(p) + 1 );
883 Cba_ManBoxNumRec_rec( pNtk, pCountP, pCountU );
884 *pnPrims = pCountP[Cba_NtkId(pNtk)];
885 *pnUsers = pCountU[Cba_NtkId(pNtk)];
886 ABC_FREE( pCountP );
887 ABC_FREE( pCountU );
888}
889static inline void Cba_ManPrintStats( Cba_Man_t * p, int nModules, int fVerbose )
890{
891 Cba_Ntk_t * pNtk; int i, nPrims, nUsers;
892 Cba_Ntk_t * pRoot = Cba_ManRoot( p );
893 Cba_ManBoxNumRec( p, &nPrims, &nUsers );
894 printf( "%-12s : ", Cba_ManName(p) );
895 printf( "pi =%5d ", Cba_NtkPiNum(pRoot) );
896 printf( "po =%5d ", Cba_NtkPoNum(pRoot) );
897 printf( "mod =%5d ", Cba_ManNtkNum(p) );
898 printf( "box =%5d ", nPrims + nUsers );
899 printf( "prim =%5d ", nPrims );
900 printf( "user =%5d ", nUsers );
901 printf( "mem =%6.3f MB", 1.0*Cba_ManMemory(p)/(1<<20) );
902 printf( "\n" );
903 Cba_ManForEachNtk( p, pNtk, i )
904 {
905 if ( i == nModules+1 )
906 break;
907 printf( "Module %5d : ", i );
908 Cba_NtkPrintStats( pNtk );
909 }
910}
911
912
924static inline void Cba_NtkAddMissingFonNames( Cba_Ntk_t * p, char * pPref )
925{
926 int iFon, NameId, Index;
927 // populate map
928 Cba_ManCleanMap( p->pDesign );
929 Vec_IntForEachEntryStart( &p->vFonName, NameId, iFon, 1 )
930 if ( NameId )
931 Cba_ManSetMap( p->pDesign, NameId, iFon );
932 // check remaining ones
933 Vec_IntForEachEntryStart( &p->vFonName, NameId, iFon, 1 )
934 {
935 if ( NameId )
936 continue;
937 NameId = Cba_NtkNewStrId(p, "%s%d", pPref, iFon);
938 for ( Index = 1; Cba_ManGetMap(p->pDesign, NameId); Index++ )
939 NameId = Cba_NtkNewStrId(p, "%s%d_%d", pPref, iFon, Index);
940 Cba_FonSetName( p, iFon, NameId );
941 Cba_ManSetMap( p->pDesign, NameId, iFon );
942 }
943}
944static inline void Cba_NtkCreateFonNames( Cba_Ntk_t * p, char * pPref )
945{
946 int i, iObj, iFon;//, NameId;
947 Cba_NtkCleanFonNames( p );
948 Cba_NtkForEachPiFon( p, iObj, iFon, i )
949 if ( !Cba_FonName(p, iFon) )
950 Cba_FonSetName( p, iFon, Cba_ObjName(p, iObj) );
951 Cba_NtkForEachPoDriverFon( p, iObj, iFon, i )
952 if ( Cba_FonIsReal(iFon) && !Cba_FonName(p, iFon) )
953 Cba_FonSetName( p, iFon, Cba_ObjName(p, iObj) );
954// Vec_IntForEachEntryStart( &p->vFonName, NameId, iFon, 1 )
955// if ( NameId == 0 )
956// Vec_IntWriteEntry( &p->vFonName, iFon, Cba_NtkNewStrId(p, "%s%d", pPref, iFon) );
957 Cba_NtkAddMissingFonNames( p, pPref );
958}
959static inline void Cba_NtkMissingFonNames( Cba_Ntk_t * p, char * pPref )
960{
961 int i, iObj, iFon;//, NameId;
962 Cba_NtkForEachPiFon( p, iObj, iFon, i )
963 if ( !Cba_FonName(p, iFon) )
964 Cba_FonSetName( p, iFon, Cba_ObjName(p, iObj) );
965 Cba_NtkForEachPoDriverFon( p, iObj, iFon, i )
966 if ( Cba_FonIsReal(iFon) && !Cba_FonName(p, iFon) )
967 Cba_FonSetName( p, iFon, Cba_ObjName(p, iObj) );
968// Vec_IntForEachEntryStart( &p->vFonName, NameId, iFon, 1 )
969// if ( NameId == 0 )
970// Cba_FonSetName( p, iFon, Cba_NtkNewStrId(p, "%s%d", pPref, iFon) );
971 Cba_NtkAddMissingFonNames( p, pPref );
972}
973
974
975/*=== cbaBlast.c =============================================================*/
976extern Gia_Man_t * Cba_ManBlast( Cba_Man_t * p, int fBarBufs, int fSeq, int fVerbose );
977extern Cba_Man_t * Cba_ManInsertGia( Cba_Man_t * p, Gia_Man_t * pGia );
978extern Cba_Man_t * Cba_ManInsertAbc( Cba_Man_t * p, void * pAbc );
979/*=== cbaCba.c ===============================================================*/
980extern Cba_Man_t * Cba_ManReadCba( char * pFileName );
981extern void Cba_ManWriteCba( char * pFileName, Cba_Man_t * p );
982/*=== cbaCom.c ===============================================================*/
983/*=== cbaNtk.c ===============================================================*/
984extern void Cba_NtkPrintStatsFull( Cba_Ntk_t * p, int fDistrib, int fVerbose );
985extern void Cba_NtkPrintNodes( Cba_Ntk_t * p, int Type );
986extern void Cba_NtkPrintDistribOld( Cba_Ntk_t * p );
987extern void Cba_ManPrintDistrib( Cba_Man_t * p );
988//extern void Cba_ManPrepareTypeNames( Cba_Man_t * p );
989extern void Cba_NtkObjOrder( Cba_Ntk_t * p, Vec_Int_t * vObjs, Vec_Int_t * vNameIds );
990extern int Cba_NtkCiFonNum( Cba_Ntk_t * p );
991extern int Cba_NtkCoFinNum( Cba_Ntk_t * p );
992extern int Cba_NtkCheckComboLoop( Cba_Ntk_t * p );
993extern int Cba_ManIsTopoOrder( Cba_Man_t * p );
994extern Vec_Int_t * Cba_NtkCollectDfs( Cba_Ntk_t * p );
995extern Cba_Man_t * Cba_ManCollapse( Cba_Man_t * p );
996extern Cba_Man_t * Cba_ManExtractGroup( Cba_Man_t * p, Vec_Int_t * vObjs );
997extern Cba_Man_t * Cba_ManDeriveFromGia( Cba_Man_t * p, Gia_Man_t * pGia, int fUseXor );
998extern Cba_Man_t * Cba_ManInsertGroup( Cba_Man_t * p, Vec_Int_t * vObjs, Cba_Ntk_t * pSyn );
999/*=== cbaReadBlif.c ==========================================================*/
1000extern Cba_Man_t * Prs_ManBuildCbaBlif( char * pFileName, Vec_Ptr_t * vDes );
1001extern void Prs_ManReadBlifTest( char * pFileName );
1002extern Cba_Man_t * Cba_ManReadBlif( char * pFileName );
1003/*=== cbaReadVer.c ===========================================================*/
1004extern Cba_Man_t * Prs_ManBuildCbaVerilog( char * pFileName, Vec_Ptr_t * vDes );
1005extern void Prs_ManReadVerilogTest( char * pFileName );
1006extern Cba_Man_t * Cba_ManReadVerilog( char * pFileName );
1007/*=== cbaWriteBlif.c =========================================================*/
1008extern void Prs_ManWriteBlif( char * pFileName, Vec_Ptr_t * p );
1009extern void Cba_ManWriteBlif( char * pFileName, Cba_Man_t * p );
1010/*=== cbaWriteVer.c ==========================================================*/
1011extern void Cba_ManCreatePrimMap( char ** pMap );
1012extern char * Cba_ManGetSliceName( Cba_Ntk_t * p, int iFon, int RangeId );
1013extern void Prs_ManWriteVerilog( char * pFileName, Vec_Ptr_t * p );
1014extern void Cba_ManWriteVerilog( char * pFileName, Cba_Man_t * p, int fInlineConcat );
1015
1016ABC_NAMESPACE_HEADER_END
1017
1018
1019#endif
1020
1024
ABC_FALLOC
#define ABC_FALLOC(type, num)
Definition abc_global.h:266
ABC_CALLOC
#define ABC_CALLOC(type, num)
Definition abc_global.h:265
ABC_FREE
#define ABC_FREE(obj)
Definition abc_global.h:267
ABC_NAMESPACE_HEADER_END
#define ABC_NAMESPACE_HEADER_END
Definition abc_namespaces.h:51
ABC_NAMESPACE_HEADER_START
#define ABC_NAMESPACE_HEADER_START
NAMESPACES ///.
Definition abc_namespaces.h:50
Vec_Int_t
typedefABC_NAMESPACE_IMPL_START struct Vec_Int_t_ Vec_Int_t
DECLARATIONS ///.
Definition bblif.c:37
Vec_Str_t
struct Vec_Str_t_ Vec_Str_t
Definition bblif.c:46
Cba_ObjType_t
Cba_ObjType_t
INCLUDES ///.
Definition cbaTypes.h:39
CBA_BOX_INV
@ CBA_BOX_INV
Definition cbaTypes.h:51
CBA_OBJ_BOX
@ CBA_OBJ_BOX
Definition cbaTypes.h:43
CBA_BOX_GATE
@ CBA_BOX_GATE
Definition cbaTypes.h:123
CBA_BOX_RAM
@ CBA_BOX_RAM
Definition cbaTypes.h:127
CBA_BOX_LNOT
@ CBA_BOX_LNOT
Definition cbaTypes.h:78
CBA_BOX_BUF
@ CBA_BOX_BUF
Definition cbaTypes.h:50
CBA_BOX_NMUX
@ CBA_BOX_NMUX
Definition cbaTypes.h:86
CBA_BOX_MIN
@ CBA_BOX_MIN
Definition cbaTypes.h:102
CBA_BOX_MUX
@ CBA_BOX_MUX
Definition cbaTypes.h:60
CBA_BOX_RXNOR
@ CBA_BOX_RXNOR
Definition cbaTypes.h:76
CBA_BOX_PSEL
@ CBA_BOX_PSEL
Definition cbaTypes.h:88
CBA_BOX_SEL
@ CBA_BOX_SEL
Definition cbaTypes.h:87
CBA_BOX_ABS
@ CBA_BOX_ABS
Definition cbaTypes.h:104
CBA_BOX_LAST
@ CBA_BOX_LAST
Definition cbaTypes.h:144
CBA_OBJ_PI
@ CBA_OBJ_PI
Definition cbaTypes.h:41
CBA_BOX_SQRT
@ CBA_BOX_SQRT
Definition cbaTypes.h:103
CBA_BOX_RAND
@ CBA_BOX_RAND
Definition cbaTypes.h:71
CBA_BOX_SLICE
@ CBA_BOX_SLICE
Definition cbaTypes.h:141
CBA_OBJ_NONE
@ CBA_OBJ_NONE
Definition cbaTypes.h:40
CBA_OBJ_PO
@ CBA_OBJ_PO
Definition cbaTypes.h:42
CBA_BOX_DFFRS
@ CBA_BOX_DFFRS
Definition cbaTypes.h:139
CBA_BOX_CONCAT
@ CBA_BOX_CONCAT
Definition cbaTypes.h:142
Cba_ManPrintDistrib
void Cba_ManPrintDistrib(Cba_Man_t *p)
Definition cbaNtk.c:354
Cba_ManExtractGroup
Cba_Man_t * Cba_ManExtractGroup(Cba_Man_t *p, Vec_Int_t *vObjs)
Definition cbaNtk.c:959
Cba_NtkPrintNodes
void Cba_NtkPrintNodes(Cba_Ntk_t *p, int Type)
Definition cbaNtk.c:242
Prs_ManWriteVerilog
void Prs_ManWriteVerilog(char *pFileName, Vec_Ptr_t *p)
Definition cbaWriteVer.c:322
Cba_NtkForEachObj
#define Cba_NtkForEachObj(p, i)
Definition cba.h:324
Prs_ManReadVerilogTest
void Prs_ManReadVerilogTest(char *pFileName)
Definition cbaReadVer.c:1394
Cba_NtkForEachPioOrder
#define Cba_NtkForEachPioOrder(p, iObj, i)
Definition cba.h:314
Cba_ManReadBlif
Cba_Man_t * Cba_ManReadBlif(char *pFileName)
Definition cbaReadBlif.c:629
Cba_ManInsertAbc
Cba_Man_t * Cba_ManInsertAbc(Cba_Man_t *p, void *pAbc)
Definition cbaBlast.c:1057
Prs_ManReadBlifTest
void Prs_ManReadBlifTest(char *pFileName)
Definition cbaReadBlif.c:433
Cba_ManInsertGroup
Cba_Man_t * Cba_ManInsertGroup(Cba_Man_t *p, Vec_Int_t *vObjs, Cba_Ntk_t *pSyn)
Definition cbaNtk.c:1170
Cba_NtkForEachBox
#define Cba_NtkForEachBox(p, i)
Definition cba.h:328
Cba_ManIsTopoOrder
int Cba_ManIsTopoOrder(Cba_Man_t *p)
Definition cbaNtk.c:540
Cba_ManBlast
Gia_Man_t * Cba_ManBlast(Cba_Man_t *p, int fBarBufs, int fSeq, int fVerbose)
Definition cbaBlast.c:1037
Cba_ObjForEachFin
#define Cba_ObjForEachFin(p, iObj, iFin, k)
Definition cba.h:344
Cba_ObjForEachFinFon
#define Cba_ObjForEachFinFon(p, iObj, iFin, iFon, k)
Definition cba.h:348
Cba_ManReadCba
Cba_Man_t * Cba_ManReadCba(char *pFileName)
DECLARATIONS ///.
Definition cbaCba.c:44
Cba_NtkPrintDistribOld
void Cba_NtkPrintDistribOld(Cba_Ntk_t *p)
Definition cbaNtk.c:332
Cba_ManWriteVerilog
void Cba_ManWriteVerilog(char *pFileName, Cba_Man_t *p, int fInlineConcat)
Definition cbaWriteVer.c:975
Cba_NtkCheckComboLoop
int Cba_NtkCheckComboLoop(Cba_Ntk_t *p)
Definition cbaNtk.c:578
Prs_ManWriteBlif
void Prs_ManWriteBlif(char *pFileName, Vec_Ptr_t *p)
Definition cbaWriteBlif.c:103
Cba_ManWriteCba
void Cba_ManWriteCba(char *pFileName, Cba_Man_t *p)
Definition cbaCba.c:48
Cba_NtkCiFonNum
int Cba_NtkCiFonNum(Cba_Ntk_t *p)
Definition cbaNtk.c:472
Cba_ManCollapse
Cba_Man_t * Cba_ManCollapse(Cba_Man_t *p)
Definition cbaNtk.c:788
Cba_NtkPrintStatsFull
void Cba_NtkPrintStatsFull(Cba_Ntk_t *p, int fDistrib, int fVerbose)
Definition cbaNtk.c:267
Cba_ObjForEachFon
#define Cba_ObjForEachFon(p, iObj, iFon, k)
Definition cba.h:346
Cba_NtkForEachObjType
#define Cba_NtkForEachObjType(p, Type, i)
Definition cba.h:326
Cba_NtkObjOrder
void Cba_NtkObjOrder(Cba_Ntk_t *p, Vec_Int_t *vObjs, Vec_Int_t *vNameIds)
Definition cbaNtk.c:428
Cba_Ntk_t
typedefABC_NAMESPACE_HEADER_START struct Cba_Ntk_t_ Cba_Ntk_t
INCLUDES ///.
Definition cba.h:45
Prs_ManBuildCbaBlif
Cba_Man_t * Prs_ManBuildCbaBlif(char *pFileName, Vec_Ptr_t *vDes)
Definition cbaReadBlif.c:587
Cba_ManReadVerilog
Cba_Man_t * Cba_ManReadVerilog(char *pFileName)
Definition cbaReadVer.c:2165
Cba_NtkForEachPiFon
#define Cba_NtkForEachPiFon(p, iObj, iFon, i)
Definition cba.h:317
Cba_NtkForEachPoDriverFon
#define Cba_NtkForEachPoDriverFon(p, iObj, iFon, i)
Definition cba.h:319
Cba_ManGetSliceName
char * Cba_ManGetSliceName(Cba_Ntk_t *p, int iFon, int RangeId)
Definition cbaWriteVer.c:381
Cba_Man_t
struct Cba_Man_t_ Cba_Man_t
Definition cba.h:46
Cba_NtkCollectDfs
Vec_Int_t * Cba_NtkCollectDfs(Cba_Ntk_t *p)
Definition cbaNtk.c:640
Cba_ManForEachNtk
#define Cba_ManForEachNtk(p, pNtk, i)
ITERATORS ///.
Definition cba.h:305
Cba_ManDeriveFromGia
Cba_Man_t * Cba_ManDeriveFromGia(Cba_Man_t *p, Gia_Man_t *pGia, int fUseXor)
Definition cbaNtk.c:1053
Cba_ManWriteBlif
void Cba_ManWriteBlif(char *pFileName, Cba_Man_t *p)
Definition cbaWriteBlif.c:187
Cba_NtkCoFinNum
int Cba_NtkCoFinNum(Cba_Ntk_t *p)
Definition cbaNtk.c:479
Cba_ManCreatePrimMap
void Cba_ManCreatePrimMap(char **pMap)
DECLARATIONS ///.
Definition cbaWriteVer.c:47
Prs_ManBuildCbaVerilog
Cba_Man_t * Prs_ManBuildCbaVerilog(char *pFileName, Vec_Ptr_t *vDes)
Definition cbaReadVer.c:2123
Cba_ManInsertGia
Cba_Man_t * Cba_ManInsertGia(Cba_Man_t *p, Gia_Man_t *pGia)
Definition cbaBlast.c:1053
p
Cube * p
Definition exorList.c:222
Extra_FileDesignName
char * Extra_FileDesignName(char *pFileName)
Definition extraUtilFile.c:269
Gia_Man_t
struct Gia_Man_t_ Gia_Man_t
Definition gia.h:96
if
if(last==0)
Definition sparse_int.h:34
Cba_Man_t_
Definition cba.h:92
Cba_Man_t_::nOpens
int nOpens
Definition cba.h:111
Cba_Man_t_::vOut2
Vec_Str_t vOut2
Definition cba.h:113
Cba_Man_t_::pStrs
Abc_Nam_t * pStrs
Definition cba.h:96
Cba_Man_t_::nAnds
int nAnds[CBA_BOX_LAST]
Definition cba.h:106
Cba_Man_t_::nObjs
int nObjs[CBA_BOX_LAST]
Definition cba.h:105
Cba_Man_t_::vOut
Vec_Str_t vOut
Definition cba.h:112
Cba_Man_t_::pFuns
Abc_Nam_t * pFuns
Definition cba.h:97
Cba_Man_t_::vNameMap2
Vec_Int_t vNameMap2
Definition cba.h:101
Cba_Man_t_::vHash
Hash_IntMan_t * vHash
Definition cba.h:99
Cba_Man_t_::pSpec
char * pSpec
Definition cba.h:95
Cba_Man_t_::pMods
Abc_Nam_t * pMods
Definition cba.h:98
Cba_Man_t_::vNameMap
Vec_Int_t vNameMap
Definition cba.h:100
Cba_Man_t_::vNtks
Vec_Ptr_t vNtks
Definition cba.h:109
Cba_Man_t_::pTypeNames
char * pTypeNames[CBA_BOX_LAST]
Definition cba.h:104
Cba_Man_t_::iRoot
int iRoot
Definition cba.h:108
Cba_Man_t_::vUsed2
Vec_Int_t vUsed2
Definition cba.h:103
Cba_Man_t_::pMioLib
void * pMioLib
Definition cba.h:114
Cba_Man_t_::vUsed
Vec_Int_t vUsed
Definition cba.h:102
Cba_Man_t_::pName
char * pName
Definition cba.h:94
Cba_Ntk_t_
Definition cba.h:50
Cba_Ntk_t_::vObjFin0
Vec_Int_t vObjFin0
Definition cba.h:65
Cba_Ntk_t_::fSeq
unsigned fSeq
Definition cba.h:57
Cba_Ntk_t_::vArray0
Vec_Int_t vArray0
Definition cba.h:86
Cba_Ntk_t_::fComb
unsigned fComb
Definition cba.h:56
Cba_Ntk_t_::vFonRange
Vec_Int_t vFonRange
Definition cba.h:77
Cba_Ntk_t_::vInputs
Vec_Int_t vInputs
Definition cba.h:59
Cba_Ntk_t_::pDesign
Cba_Man_t * pDesign
Definition cba.h:51
Cba_Ntk_t_::vNtkObjs
Vec_Int_t vNtkObjs
Definition cba.h:82
Cba_Ntk_t_::vOther
Vec_Ptr_t * vOther
Definition cba.h:85
Cba_Ntk_t_::vObjName
Vec_Int_t vObjName
Definition cba.h:72
Cba_Ntk_t_::vOutputs
Vec_Int_t vOutputs
Definition cba.h:60
Cba_Ntk_t_::vFinFon
Vec_Int_t vFinFon
Definition cba.h:67
Cba_Ntk_t_::vFonPrev
Vec_Int_t vFonPrev
Definition cba.h:78
Cba_Ntk_t_::vArray1
Vec_Int_t vArray1
Definition cba.h:87
Cba_Ntk_t_::vFonName
Vec_Int_t vFonName
Definition cba.h:76
Cba_Ntk_t_::vFinObj
Vec_Int_t vFinObj
Definition cba.h:81
Cba_Ntk_t_::vFonNext
Vec_Int_t vFonNext
Definition cba.h:79
Cba_Ntk_t_::vObjFunc
Vec_Int_t vObjFunc
Definition cba.h:71
Cba_Ntk_t_::vFonBits
Vec_Int_t vFonBits
Definition cba.h:83
Cba_Ntk_t_::vFinFon0
Vec_Int_t vFinFon0
Definition cba.h:80
Cba_Ntk_t_::vObjFon0
Vec_Int_t vObjFon0
Definition cba.h:66
Cba_Ntk_t_::vAttrSto
Vec_Int_t vAttrSto
Definition cba.h:74
Cba_Ntk_t_::NameId
int NameId
Definition cba.h:53
Cba_Ntk_t_::vObjType
Vec_Str_t vObjType
Definition cba.h:64
Cba_Ntk_t_::vFonObj
Vec_Int_t vFonObj
Definition cba.h:68
Cba_Ntk_t_::vObjCopy
Vec_Int_t vObjCopy
Definition cba.h:70
Cba_Ntk_t_::vOrder
Vec_Int_t vOrder
Definition cba.h:61
Cba_Ntk_t_::Id
int Id
Definition cba.h:52
Cba_Ntk_t_::Mark
unsigned Mark
Definition cba.h:55
Cba_Ntk_t_::vSeq
Vec_Int_t vSeq
Definition cba.h:62
Cba_Ntk_t_::iCopy
int iCopy
Definition cba.h:54
Cba_Ntk_t_::vFonCopy
Vec_Int_t vFonCopy
Definition cba.h:75
Cba_Ntk_t_::vObjAttr
Vec_Int_t vObjAttr
Definition cba.h:73
Abc_NamStrFind
int Abc_NamStrFind(Abc_Nam_t *p, char *pStr)
Definition utilNam.c:433
Abc_NamStrFindOrAddLim
int Abc_NamStrFindOrAddLim(Abc_Nam_t *p, char *pStr, char *pLim, int *pfFound)
Definition utilNam.c:492
Abc_NamMemUsed
int Abc_NamMemUsed(Abc_Nam_t *p)
Definition utilNam.c:247
Abc_NamStrFindOrAdd
int Abc_NamStrFindOrAdd(Abc_Nam_t *p, char *pStr, int *pfFound)
Definition utilNam.c:453
Abc_NamObjNumMax
int Abc_NamObjNumMax(Abc_Nam_t *p)
Definition utilNam.c:231
Abc_NamStart
Abc_Nam_t * Abc_NamStart(int nObjs, int nAveSize)
FUNCTION DEFINITIONS ///.
Definition utilNam.c:80
Abc_NamBuffer
Vec_Str_t * Abc_NamBuffer(Abc_Nam_t *p)
Definition utilNam.c:571
Abc_NamDeref
void Abc_NamDeref(Abc_Nam_t *p)
Definition utilNam.c:212
Abc_NamRef
Abc_Nam_t * Abc_NamRef(Abc_Nam_t *p)
Definition utilNam.c:195
Abc_NamStr
char * Abc_NamStr(Abc_Nam_t *p, int NameId)
Definition utilNam.c:555
Abc_Nam_t
typedefABC_NAMESPACE_HEADER_START struct Abc_Nam_t_ Abc_Nam_t
INCLUDES ///.
Definition utilNam.h:39
assert
#define assert(ex)
Definition util_old.h:213
memcpy
char * memcpy()
strlen
int strlen()
strchr
char * strchr()
Hash_IntMan_t
struct Hash_IntMan_t_ Hash_IntMan_t
Definition vecHash.h:51
Vec_IntForEachEntry
#define Vec_IntForEachEntry(vVec, Entry, i)
MACRO DEFINITIONS ///.
Definition vecInt.h:54
Vec_IntForEachEntryStart
#define Vec_IntForEachEntryStart(vVec, Entry, i, Start)
Definition vecInt.h:56
Vec_Ptr_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Ptr_t_ Vec_Ptr_t
INCLUDES ///.
Definition vecPtr.h:42
Vec_Vec_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Vec_t_ Vec_Vec_t
INCLUDES ///.
Definition vecVec.h:42