ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
bac.h
Go to the documentation of this file.
1
20
21#ifndef ABC__base__bac__bac_h
22#define ABC__base__bac__bac_h
23
27
28#include "aig/gia/gia.h"
29#include "misc/extra/extra.h"
30#include "misc/util/utilNam.h"
31
35
36ABC_NAMESPACE_HEADER_START
37
41
42// network objects
130
131
132// name types
133typedef enum {
134 BAC_NAME_BIN = 0, // 0: binary variable
135 BAC_NAME_WORD, // 1: first bit of word-level variable
136 BAC_NAME_INFO, // 2: first bit of special variable
137 BAC_NAME_INDEX, // 3: index of word-level variable
138} Bac_NameType_t;
139
140
141typedef struct Bac_Ntk_t_ Bac_Ntk_t;
142typedef struct Bac_Man_t_ Bac_Man_t;
143
144// network
145struct Bac_Ntk_t_
146{
147 Bac_Man_t * pDesign; // design
148 int NameId; // name ID
149 int iCopy; // copy module
150 int iBoxNtk; // instance network ID
151 int iBoxObj; // instance object ID
152 int Count; // object counter
153 int Mark; // visit mark
154 // interface
155 Vec_Int_t vInputs; // inputs
156 Vec_Int_t vOutputs; // outputs
157 Vec_Int_t vInfo; // input/output/wire info
158 // object attributes
159 Vec_Str_t vType; // types
160 Vec_Int_t vFanin; // fanin
161 Vec_Int_t vIndex; // index
162 Vec_Int_t vName; // original NameId or InstId
163 Vec_Int_t vFanout; // fanout
164 Vec_Int_t vCopy; // copy
165 // other
166 Vec_Int_t vArray;
167 Vec_Int_t vArray2;
168};
169
170// design
171struct Bac_Man_t_
172{
173 // design names
174 char * pName; // design name
175 char * pSpec; // spec file name
176 Abc_Nam_t * pStrs; // string manager
177 Abc_Nam_t * pMods; // module name manager
178 // internal data
179 int iRoot; // root network
180 int nNtks; // number of current networks
181 Bac_Ntk_t * pNtks; // networks
182 // user data
183 Vec_Str_t * vOut;
184 Vec_Str_t * vOut2;
185 Vec_Int_t vBuf2RootNtk;
186 Vec_Int_t vBuf2RootObj;
187 Vec_Int_t vBuf2LeafNtk;
188 Vec_Int_t vBuf2LeafObj;
189 void * pMioLib;
190 void ** ppGraphs;
191 int ElemGates[4];
192 char * pPrimNames[BAC_BOX_UNKNOWN];
193 char * pPrimSymbs[BAC_BOX_UNKNOWN];
194};
195
196static inline char * Bac_ManName( Bac_Man_t * p ) { return p->pName; }
197static inline char * Bac_ManSpec( Bac_Man_t * p ) { return p->pSpec; }
198static inline int Bac_ManNtkNum( Bac_Man_t * p ) { return p->nNtks; }
199static inline int Bac_ManPrimNum( Bac_Man_t * p ) { return Abc_NamObjNumMax(p->pMods) - Bac_ManNtkNum(p); }
200static inline int Bac_ManNtkIsOk( Bac_Man_t * p, int i ) { return i > 0 && i <= Bac_ManNtkNum(p); }
201static inline Bac_Ntk_t * Bac_ManNtk( Bac_Man_t * p, int i ) { return Bac_ManNtkIsOk(p, i) ? p->pNtks + i : NULL; }
202static inline int Bac_ManNtkFindId( Bac_Man_t * p, char * pName ) { return Abc_NamStrFind(p->pMods, pName); }
203static inline Bac_Ntk_t * Bac_ManNtkFind( Bac_Man_t * p, char * pName ) { return Bac_ManNtk( p, Bac_ManNtkFindId(p, pName) ); }
204static inline Bac_Ntk_t * Bac_ManRoot( Bac_Man_t * p ) { return Bac_ManNtk(p, p->iRoot); }
205static inline char * Bac_ManStr( Bac_Man_t * p, int i ) { return Abc_NamStr(p->pStrs, i); }
206static inline int Bac_ManStrId( Bac_Man_t * p, char * pStr ) { return Abc_NamStrFind(p->pStrs, pStr); }
207static inline char * Bac_ManPrimName( Bac_Man_t * p, Bac_ObjType_t Type ) { return p->pPrimNames[Type]; }
208static inline char * Bac_ManPrimSymb( Bac_Man_t * p, Bac_ObjType_t Type ) { return p->pPrimSymbs[Type]; }
209
210static inline int Bac_NtkId( Bac_Ntk_t * p ) { int i = p - p->pDesign->pNtks; assert(Bac_ManNtkIsOk(p->pDesign, i)); return i; }
211static inline Bac_Man_t * Bac_NtkMan( Bac_Ntk_t * p ) { return p->pDesign; }
212static inline int Bac_NtkNameId( Bac_Ntk_t * p ) { return p->NameId; }
213static inline char * Bac_NtkName( Bac_Ntk_t * p ) { return Bac_ManStr(p->pDesign, Bac_NtkNameId(p)); }
214static inline int Bac_NtkCopy( Bac_Ntk_t * p ) { return p->iCopy; }
215static inline Bac_Ntk_t * Bac_NtkCopyNtk(Bac_Man_t * pNew, Bac_Ntk_t * p) { return Bac_ManNtk(pNew, Bac_NtkCopy(p)); }
216static inline void Bac_NtkSetCopy( Bac_Ntk_t * p, int i ) { assert(p->iCopy == -1); p->iCopy = i; }
217
218static inline int Bac_NtkObjNum( Bac_Ntk_t * p ) { return Vec_StrSize(&p->vType); }
219static inline int Bac_NtkObjNumAlloc( Bac_Ntk_t * p ) { return Vec_StrCap(&p->vType); }
220static inline int Bac_NtkPiNum( Bac_Ntk_t * p ) { return Vec_IntSize(&p->vInputs); }
221static inline int Bac_NtkPoNum( Bac_Ntk_t * p ) { return Vec_IntSize(&p->vOutputs); }
222static inline int Bac_NtkPioNum( Bac_Ntk_t * p ) { return Bac_NtkPiNum(p) + Bac_NtkPoNum(p); }
223static inline int Bac_NtkPiNumAlloc( Bac_Ntk_t * p ) { return Vec_IntCap(&p->vInputs); }
224static inline int Bac_NtkPoNumAlloc( Bac_Ntk_t * p ) { return Vec_IntCap(&p->vOutputs); }
225static inline int Bac_NtkBiNum( Bac_Ntk_t * p ) { return Vec_StrCountEntryLit(&p->vType, (char)BAC_OBJ_BI); }
226static inline int Bac_NtkBoNum( Bac_Ntk_t * p ) { return Vec_StrCountEntryLit(&p->vType, (char)BAC_OBJ_BO); }
227static inline int Bac_NtkCiNum( Bac_Ntk_t * p ) { return Bac_NtkPiNum(p) + Bac_NtkBoNum(p); }
228static inline int Bac_NtkCoNum( Bac_Ntk_t * p ) { return Bac_NtkPoNum(p) + Bac_NtkBiNum(p); }
229static inline int Bac_NtkBoxNum( Bac_Ntk_t * p ) { return Bac_NtkObjNum(p) - Vec_StrCountSmallerLit(&p->vType, (char)BAC_OBJ_BOX); }
230static inline int Bac_NtkPrimNum( Bac_Ntk_t * p ) { return Vec_StrCountLargerLit(&p->vType, (char)BAC_OBJ_BOX); }
231static inline int Bac_NtkUserNum( Bac_Ntk_t * p ) { return Vec_StrCountEntryLit(&p->vType, (char)BAC_OBJ_BOX); }
232
233static inline int Bac_NtkPi( Bac_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInputs, i); }
234static inline int Bac_NtkPo( Bac_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vOutputs, i); }
235static inline char * Bac_NtkStr( Bac_Ntk_t * p, int i ) { return Bac_ManStr(p->pDesign, i); }
236static inline Bac_Ntk_t * Bac_NtkHostNtk( Bac_Ntk_t * p ) { return p->iBoxNtk > 0 ? Bac_ManNtk(p->pDesign, p->iBoxNtk) : NULL; }
237static inline int Bac_NtkHostObj( Bac_Ntk_t * p ) { return p->iBoxObj; }
238static inline void Bac_NtkSetHost( Bac_Ntk_t * p, int n, int i ) { assert(p->iBoxNtk == -1); p->iBoxNtk = n; p->iBoxObj = i; }
239
240static inline int Bac_InfoRange( int Beg, int End ) { return End > Beg ? End - Beg + 1 : Beg - End + 1; }
241static inline int Bac_NtkInfoNum( Bac_Ntk_t * p ) { return Vec_IntSize(&p->vInfo)/3; }
242static inline int Bac_NtkInfoNumAlloc( Bac_Ntk_t * p ) { return Vec_IntCap(&p->vInfo)/3; }
243static inline int Bac_NtkInfoType( Bac_Ntk_t * p, int i ) { return Abc_Lit2Att2(Vec_IntEntry(&p->vInfo, 3*i)); }
244static inline int Bac_NtkInfoName( Bac_Ntk_t * p, int i ) { return Abc_Lit2Var2(Vec_IntEntry(&p->vInfo, 3*i)); }
245static inline int Bac_NtkInfoBeg( Bac_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInfo, 3*i+1); }
246static inline int Bac_NtkInfoEnd( Bac_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vInfo, 3*i+2); }
247static inline int Bac_NtkInfoRange( Bac_Ntk_t * p, int i ) { int* a = Vec_IntEntryP(&p->vInfo, 3*i); return a[1]>=0 ? Bac_InfoRange( a[1], a[2] ) : 1; }
248static inline int Bac_NtkInfoIndex( Bac_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;}
249static inline void Bac_NtkAddInfo( Bac_Ntk_t * p,int i,int b,int e){ Vec_IntPush(&p->vInfo, i); Vec_IntPushTwo(&p->vInfo, b, e); }
250static inline void Bac_NtkSetInfoName( Bac_Ntk_t * p, int i, int n){ Vec_IntWriteEntry( &p->vInfo, 3*i, n ); }
251
252static inline void Bac_NtkStartNames( Bac_Ntk_t * p ) { assert(Bac_NtkObjNumAlloc(p)); Vec_IntFill(&p->vName, Bac_NtkObjNumAlloc(p), 0); }
253static inline void Bac_NtkStartFanouts( Bac_Ntk_t * p ) { assert(Bac_NtkObjNumAlloc(p)); Vec_IntFill(&p->vFanout, Bac_NtkObjNumAlloc(p), 0); }
254static inline void Bac_NtkStartCopies( Bac_Ntk_t * p ) { assert(Bac_NtkObjNumAlloc(p)); Vec_IntFill(&p->vCopy, Bac_NtkObjNumAlloc(p), -1); }
255static inline void Bac_NtkFreeNames( Bac_Ntk_t * p ) { Vec_IntErase(&p->vName); }
256static inline void Bac_NtkFreeFanouts( Bac_Ntk_t * p ) { Vec_IntErase(&p->vFanout); }
257static inline void Bac_NtkFreeCopies( Bac_Ntk_t * p ) { Vec_IntErase(&p->vCopy); }
258static inline int Bac_NtkHasNames( Bac_Ntk_t * p ) { return p->vName.pArray != NULL; }
259static inline int Bac_NtkHasFanouts( Bac_Ntk_t * p ) { return p->vFanout.pArray != NULL; }
260static inline int Bac_NtkHasCopies( Bac_Ntk_t * p ) { return p->vCopy.pArray != NULL; }
261
262static inline int Bac_TypeIsBox( Bac_ObjType_t Type ) { return Type >= BAC_OBJ_BOX && Type < BAC_BOX_UNKNOWN; }
263static inline Bac_NameType_t Bac_NameType( int n ) { assert( n ); return (Bac_NameType_t)Abc_Lit2Att2( n ); }
264static inline int Bac_CharIsDigit( char c ) { return c >= '0' && c <= '9'; }
265
266static inline Bac_ObjType_t Bac_ObjType( Bac_Ntk_t * p, int i ) { return (Bac_ObjType_t)Abc_Lit2Var((int)(unsigned char)Vec_StrEntry(&p->vType, i)); }
267static inline int Bac_ObjIsPi( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) == BAC_OBJ_PI; }
268static inline int Bac_ObjIsPo( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) == BAC_OBJ_PO; }
269static inline int Bac_ObjIsPio( Bac_Ntk_t * p, int i ) { return Bac_ObjIsPi(p, i) || Bac_ObjIsPo(p, i); }
270static inline int Bac_ObjIsBi( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) == BAC_OBJ_BI; }
271static inline int Bac_ObjIsBo( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) == BAC_OBJ_BO; }
272static inline int Bac_ObjIsBio( Bac_Ntk_t * p, int i ) { return Bac_ObjIsBi(p, i) || Bac_ObjIsBo(p, i); }
273static inline int Bac_ObjIsBox( Bac_Ntk_t * p, int i ) { return Bac_TypeIsBox(Bac_ObjType(p, i)); }
274static inline int Bac_ObjIsBoxUser( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) == BAC_OBJ_BOX; }
275static inline int Bac_ObjIsBoxPrim( Bac_Ntk_t * p, int i ) { return Bac_ObjIsBox(p, i) && !Bac_ObjIsBoxUser(p, i); }
276static inline int Bac_ObjIsGate( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) == BAC_BOX_GATE; }
277static inline int Bac_ObjIsCi( Bac_Ntk_t * p, int i ) { return Bac_ObjIsPi(p, i) || Bac_ObjIsBo(p, i); }
278static inline int Bac_ObjIsCo( Bac_Ntk_t * p, int i ) { return Bac_ObjIsPo(p, i) || Bac_ObjIsBi(p, i); }
279static inline int Bac_ObjIsCio( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) < BAC_OBJ_BOX; }
280static inline int Bac_ObjIsConst( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) >= BAC_BOX_CF && Bac_ObjType(p, i) <= BAC_BOX_CZ; }
281static inline int Bac_ObjIsConstBin( Bac_Ntk_t * p, int i ) { return Bac_ObjType(p, i) == BAC_BOX_CF || Bac_ObjType(p, i) == BAC_BOX_CT; }
282
283static inline int Bac_ObjBit( Bac_Ntk_t * p, int i ) { assert(!Bac_ObjIsBox(p, i)); return Abc_LitIsCompl((int)Vec_StrEntry(&p->vType, i)); }
284static inline void Bac_ObjSetBit( Bac_Ntk_t * p, int i ) { char *q = Vec_StrArray(&p->vType); assert(!Bac_ObjIsBox(p, i)); q[i] = (char)Abc_LitNot((int)q[i]); }
285static inline int Bac_ObjFanin( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsCo(p, i)); return Vec_IntEntry(&p->vFanin, i); }
286static inline int Bac_ObjIndex( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsCio(p, i)); return Vec_IntEntry(&p->vIndex, i); }
287static inline int Bac_ObjNameInt( Bac_Ntk_t * p, int i ) { assert(!Bac_ObjIsCo(p, i)); return Vec_IntEntry(&p->vName, i); }
288static inline int Bac_ObjName( Bac_Ntk_t * p, int i ) { return Bac_ObjIsCo(p, i) ? Bac_ObjNameInt(p, Bac_ObjFanin(p,i)) : Bac_ObjNameInt(p, i); }
289static inline Bac_NameType_t Bac_ObjNameType( Bac_Ntk_t * p, int i ) { return Bac_NameType( Bac_ObjName(p, i) ); }
290static inline int Bac_ObjNameId( Bac_Ntk_t * p, int i ) { return Abc_Lit2Var2( Bac_ObjName(p, i) ); }
291static inline char * Bac_ObjNameStr( Bac_Ntk_t * p, int i ) { assert(Bac_ObjNameType(p, i) <= BAC_NAME_WORD); return Bac_NtkStr(p, Bac_ObjNameId(p, i)); }
292static inline int Bac_ObjCopy( Bac_Ntk_t * p, int i ) { return Vec_IntEntry(&p->vCopy, i); }
293static inline int Bac_ObjFanout( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsCi(p, i)); return Vec_IntEntry(&p->vFanout, i); }
294static inline int Bac_ObjNextFanout( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsCo(p, i)); return Vec_IntEntry(&p->vFanout, i); }
295static inline void Bac_ObjSetFanout( Bac_Ntk_t * p, int i, int x ) { assert(Bac_ObjIsCi(p, i)); Vec_IntSetEntry(&p->vFanout, i, x); }
296static inline void Bac_ObjSetNextFanout( Bac_Ntk_t * p,int i,int x){ assert(Bac_ObjIsCo(p, i)); Vec_IntSetEntry(&p->vFanout, i, x); }
297static inline void Bac_ObjCleanFanin( Bac_Ntk_t * p, int i ) { assert(Bac_ObjFanin(p, i) >= 0 && Bac_ObjIsCo(p, i)); Vec_IntSetEntry( &p->vFanin, i, -1); }
298static inline void Bac_ObjSetFanin( Bac_Ntk_t * p, int i, int x ) { assert(Bac_ObjFanin(p, i) == -1 && Bac_ObjIsCo(p, i)); Vec_IntSetEntry( &p->vFanin, i, x); }
299static inline void Bac_ObjSetIndex( Bac_Ntk_t * p, int i, int x ) { assert(Bac_ObjIndex(p, i) == -1); Vec_IntSetEntry( &p->vIndex, i, x ); }
300static inline void Bac_ObjSetName( Bac_Ntk_t * p, int i, int x ) { assert(Bac_ObjName(p, i) == 0 && !Bac_ObjIsCo(p, i)); Vec_IntSetEntry( &p->vName, i, x ); }
301static inline void Bac_ObjSetCopy( Bac_Ntk_t * p, int i, int x ) { assert(Bac_ObjCopy(p, i) == -1); Vec_IntSetEntry( &p->vCopy, i, x ); }
302static inline int Bac_ObjGetConst( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsCi(p, i)); return Bac_ObjIsBo(p, i) && Bac_ObjIsConst(p, i-1) ? Bac_ObjType(p, i-1) : 0; }
303
304static inline int Bac_BoxBiNum( Bac_Ntk_t * p, int i ) { int s = i-1; assert(Bac_ObjIsBox(p, i)); while (--i >= 0 && Bac_ObjIsBi(p, i)) {} return s - i; }
305static inline int Bac_BoxBoNum( Bac_Ntk_t * p, int i ) { int s = i+1; assert(Bac_ObjIsBox(p, i)); while (++i < Bac_NtkObjNum(p) && Bac_ObjIsBo(p, i)) {} return i - s; }
306static inline int Bac_BoxSize( Bac_Ntk_t * p, int i ) { return 1 + Bac_BoxBiNum(p, i) + Bac_BoxBoNum(p, i); }
307static inline int Bac_BoxBi( Bac_Ntk_t * p, int b, int i ) { assert(Bac_ObjIsBox(p, b)); return b - 1 - i; }
308static inline int Bac_BoxBo( Bac_Ntk_t * p, int b, int i ) { assert(Bac_ObjIsBox(p, b)); return b + 1 + i; }
309//static inline int Bac_BoxBiBox( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsBi(p, i)); return i + 1 + Bac_ObjIndex(p, i); }
310static inline int Bac_BoxBoBox( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsBo(p, i)); return i - 1 - Bac_ObjIndex(p, i); }
311static inline int Bac_BoxFanin( Bac_Ntk_t * p, int b, int i ) { return Bac_ObjFanin(p, Bac_BoxBi(p, b, i)); }
312static inline int Bac_BoxFaninBox( Bac_Ntk_t * p, int b, int i ) { return Bac_BoxBoBox(p, Bac_BoxFanin(p, b, i)); }
313static inline int Bac_BoxBiRange( Bac_Ntk_t * p, int i ) { int s = i; assert(Bac_ObjIsBi(p, i) && !Bac_ObjBit(p, i)); while (--i >= 0 && Bac_ObjIsBi(p, i) && Bac_ObjBit(p, i)) {} return s - i; }
314static inline int Bac_BoxBoRange( Bac_Ntk_t * p, int i ) { int s = i; assert(Bac_ObjIsBo(p, i) && !Bac_ObjBit(p, i)); while (++i < Bac_NtkObjNum(p) && Bac_ObjIsBo(p, i) && Bac_ObjBit(p, i)) {} return i - s; }
315static inline int Bac_ObjPiRange( Bac_Ntk_t * p, int i ) { int s = i; assert(Bac_ObjIsPi(p, i) && !Bac_ObjBit(p, i)); while (++i < Bac_NtkObjNum(p) && Bac_ObjIsPi(p, i) && Bac_ObjBit(p, i)) {} return i - s; }
316
317static inline int Bac_BoxNtkId( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsBox(p, i)); return Vec_IntEntry(&p->vFanin, i); }
318static inline void Bac_BoxSetNtkId( Bac_Ntk_t * p, int i, int x ) { assert(Bac_ObjIsBox(p, i)&&Bac_ManNtkIsOk(p->pDesign, x));Vec_IntSetEntry(&p->vFanin, i, x);}
319//static inline int Bac_BoxBiNtkId( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsBi(p, i)); return Bac_BoxNtkId(p, Bac_BoxBiBox(p, i)); }
320static inline int Bac_BoxBoNtkId( Bac_Ntk_t * p, int i ) { assert(Bac_ObjIsBo(p, i)); return Bac_BoxNtkId(p, Bac_BoxBoBox(p, i)); }
321static inline Bac_Ntk_t * Bac_BoxNtk( Bac_Ntk_t * p, int i ) { return Bac_ManNtk( p->pDesign, Bac_BoxNtkId(p, i) ); }
322//static inline Bac_Ntk_t * Bac_BoxBiNtk( Bac_Ntk_t * p, int i ) { return Bac_ManNtk( p->pDesign, Bac_BoxBiNtkId(p, i) ); }
323static inline Bac_Ntk_t * Bac_BoxBoNtk( Bac_Ntk_t * p, int i ) { return Bac_ManNtk( p->pDesign, Bac_BoxBoNtkId(p, i) ); }
324static inline char * Bac_BoxNtkName( Bac_Ntk_t * p, int i ) { return Abc_NamStr( p->pDesign->pMods, Bac_BoxNtkId(p, i) ); }
325
329
333
334#define Bac_ManForEachNtk( p, pNtk, i ) \
335 for ( i = 1; (i <= Bac_ManNtkNum(p)) && (((pNtk) = Bac_ManNtk(p, i)), 1); i++ )
336
337#define Bac_NtkForEachPi( p, iObj, i ) \
338 for ( i = 0; (i < Bac_NtkPiNum(p)) && (((iObj) = Bac_NtkPi(p, i)), 1); i++ )
339#define Bac_NtkForEachPo( p, iObj, i ) \
340 for ( i = 0; (i < Bac_NtkPoNum(p)) && (((iObj) = Bac_NtkPo(p, i)), 1); i++ )
341#define Bac_NtkForEachPoDriver( p, iObj, i ) \
342 for ( i = 0; (i < Bac_NtkPoNum(p)) && (((iObj) = Bac_ObjFanin(p, Bac_NtkPo(p, i))), 1); i++ )
343
344#define Bac_NtkForEachPiMain( p, iObj, i ) \
345 for ( i = 0; (i < Bac_NtkPiNum(p)) && (((iObj) = Bac_NtkPi(p, i)), 1); i++ ) if ( Bac_ObjBit(p, iObj) ) {} else
346#define Bac_NtkForEachPoMain( p, iObj, i ) \
347 for ( i = 0; (i < Bac_NtkPoNum(p)) && (((iObj) = Bac_NtkPo(p, i)), 1); i++ ) if ( Bac_ObjBit(p, iObj) ) {} else
348
349#define Bac_NtkForEachObj( p, i ) if ( !Bac_ObjType(p, i) ) {} else \
350 for ( i = 0; (i < Bac_NtkObjNum(p)); i++ )
351#define Bac_NtkForEachObjType( p, Type, i ) \
352 for ( i = 0; (i < Bac_NtkObjNum(p)) && (((Type) = Bac_ObjType(p, i)), 1); i++ ) if ( !Type ) {} else
353
354#define Bac_NtkForEachBox( p, i ) \
355 for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsBox(p, i) ) {} else
356#define Bac_NtkForEachBoxUser( p, i ) \
357 for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsBoxUser(p, i) ) {} else
358#define Bac_NtkForEachBoxPrim( p, i ) \
359 for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsBoxPrim(p, i) ) {} else
360
361#define Bac_NtkForEachCi( p, i ) \
362 for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsCi(p, i) ) {} else
363#define Bac_NtkForEachCo( p, i ) \
364 for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsCo(p, i) ) {} else
365#define Bac_NtkForEachCio( p, i ) \
366 for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsCio(p, i) ){} else
367
368#define Bac_NtkForEachBi( p, i ) \
369 for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsBi(p, i) ){} else
370#define Bac_NtkForEachBo( p, i ) \
371 for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsBo(p, i) ){} else
372#define Bac_NtkForEachBio( p, i ) \
373 for ( i = 0; (i < Bac_NtkObjNum(p)); i++ ) if ( !Bac_ObjIsBio(p, i) ){} else
374
375#define Bac_BoxForEachBi( p, iBox, iTerm, i ) \
376 for ( iTerm = iBox - 1, i = 0; iTerm >= 0 && Bac_ObjIsBi(p, iTerm); iTerm--, i++ )
377#define Bac_BoxForEachBo( p, iBox, iTerm, i ) \
378 for ( iTerm = iBox + 1, i = 0; iTerm < Bac_NtkObjNum(p) && Bac_ObjIsBo(p, iTerm); iTerm++, i++ )
379#define Bac_BoxForEachBiReverse( p, iBox, iTerm, i ) \
380 for ( i = Bac_BoxBiNum(p, iBox), iTerm = iBox - i--; Bac_ObjIsBi(p, iTerm); iTerm++, i-- )
381
382#define Bac_BoxForEachBiMain( p, iBox, iTerm, i ) \
383 for ( iTerm = iBox - 1, i = 0; iTerm >= 0 && Bac_ObjIsBi(p, iTerm); iTerm--, i++ ) if ( Bac_ObjBit(p, iTerm) ) {} else
384#define Bac_BoxForEachBoMain( p, iBox, iTerm, i ) \
385 for ( iTerm = iBox + 1, i = 0; iTerm < Bac_NtkObjNum(p) && Bac_ObjIsBo(p, iTerm); iTerm++, i++ ) if ( Bac_ObjBit(p, iTerm) ) {} else
386
387#define Bac_BoxForEachFanin( p, iBox, iFanin, i ) \
388 for ( i = 0; iBox - 1 - i >= 0 && Bac_ObjIsBi(p, iBox - 1 - i) && (((iFanin) = Bac_BoxFanin(p, iBox, i)), 1); i++ )
389#define Bac_BoxForEachFaninBox( p, iBox, iFanin, i ) \
390 for ( i = 0; iBox - 1 - i >= 0 && Bac_ObjIsBi(p, iBox - 1 - i) && (((iFanin) = Bac_BoxFaninBox(p, iBox, i)), 1); i++ )
391
392#define Bac_ObjForEachFanout( p, iCi, iCo ) \
393 for ( iCo = Bac_ObjFanout(p, iCi); iCo; iCo = Bac_ObjNextFanout(p, iCo) )
394#define Bac_BoxForEachFanoutBox( p, iBox, iCo, iFanBox ) \
395 for ( assert(Bac_BoxBoNum(p, iBox) == 1), iCo = Bac_ObjFanout(p, Bac_BoxBo(p, iBox, 0)); iCo && ((iFanBox = Bac_BoxBiBox(p, iCo)), 1); iCo = Bac_ObjNextFanout(p, iCo) )
396
400
412static inline int Bac_ObjAlloc( Bac_Ntk_t * p, Bac_ObjType_t Type, int Fanin )
413{
414 int iObj = Bac_NtkObjNum(p);
415 assert( iObj == Vec_IntSize(&p->vFanin) );
416 if ( Type == BAC_OBJ_PI )
417 Vec_IntPush( &p->vInputs, iObj );
418 else if ( Type == BAC_OBJ_PO )
419 Vec_IntPush( &p->vOutputs, iObj );
420 Vec_StrPush( &p->vType, (char)Abc_Var2Lit(Type, 0) );
421 Vec_IntPush( &p->vFanin, Fanin );
422 return iObj;
423}
424static inline int Bac_ObjDup( Bac_Ntk_t * pNew, Bac_Ntk_t * p, int i )
425{
426 int iObj = Bac_ObjAlloc( pNew, Bac_ObjType(p, i), Bac_ObjIsBox(p, i) ? Bac_BoxNtkId(p, i) : -1 );
427 if ( Bac_NtkHasNames(p) && Bac_NtkHasNames(pNew) && !Bac_ObjIsCo(p, i) )
428 Bac_ObjSetName( pNew, iObj, Bac_ObjName(p, i) );
429 Bac_ObjSetCopy( p, i, iObj );
430 return iObj;
431}
432static inline int Bac_BoxAlloc( Bac_Ntk_t * p, Bac_ObjType_t Type, int nIns, int nOuts, int iNtk )
433{
434 int i, iObj;
435 for ( i = nIns - 1; i >= 0; i-- )
436 Bac_ObjAlloc( p, BAC_OBJ_BI, -1 );
437 iObj = Bac_ObjAlloc( p, Type, iNtk );
438 for ( i = 0; i < nOuts; i++ )
439 Bac_ObjAlloc( p, BAC_OBJ_BO, -1 );
440 return iObj;
441}
442static inline int Bac_BoxDup( Bac_Ntk_t * pNew, Bac_Ntk_t * p, int iBox )
443{
444 int i, iTerm, iBoxNew;
445 Bac_BoxForEachBiReverse( p, iBox, iTerm, i )
446 Bac_ObjDup( pNew, p, iTerm );
447 iBoxNew = Bac_ObjDup( pNew, p, iBox );
448 if ( Bac_NtkHasNames(p) && Bac_NtkHasNames(pNew) && Bac_ObjName(p, iBox) )
449 Bac_ObjSetName( pNew, iBoxNew, Bac_ObjName(p, iBox) );
450 if ( Bac_BoxNtk(p, iBox) )
451 Bac_BoxSetNtkId( pNew, iBoxNew, Bac_NtkCopy(Bac_BoxNtk(p, iBox)) );
452 Bac_BoxForEachBo( p, iBox, iTerm, i )
453 Bac_ObjDup( pNew, p, iTerm );
454 return iBoxNew;
455}
456static inline void Bac_BoxDelete( Bac_Ntk_t * p, int iBox )
457{
458 int iStart = iBox - Bac_BoxBiNum(p, iBox);
459 int i, iStop = iBox + Bac_BoxBoNum(p, iBox);
460 for ( i = iStart; i <= iStop; i++ )
461 {
462 Vec_StrWriteEntry( &p->vType, i, (char)0 );
463 Vec_IntWriteEntry( &p->vFanin, i, -1 );
464 if ( Bac_NtkHasNames(p) )
465 Vec_IntWriteEntry( &p->vName, i, 0 );
466 if ( Bac_NtkHasFanouts(p) )
467 Vec_IntWriteEntry( &p->vFanout, i, 0 );
468 }
469}
470static inline void Bac_BoxReplace( Bac_Ntk_t * p, int iBox, int * pArray, int nSize )
471{
472 extern void Bac_NtkUpdateFanout( Bac_Ntk_t * p, int iOld, int iNew );
473 int i, Limit = Bac_BoxBoNum(p, iBox);
474 assert( Limit == nSize );
475 for ( i = 0; i < Limit; i++ )
476 Bac_NtkUpdateFanout( p, Bac_BoxBo(p, iBox, i), pArray[i] );
477}
478
479
480static inline Vec_Int_t * Bac_BoxCollectRanges( Bac_Ntk_t * p, int iBox )
481{
482 static Vec_Int_t Bits, * vBits = &Bits;
483 static int pArray[10]; int i, iTerm;
484 assert( !Bac_ObjIsBoxUser(p, iBox) );
485 // initialize array
486 vBits->pArray = pArray;
487 vBits->nSize = 0;
488 vBits->nCap = 10;
489 // iterate through inputs
490 Bac_BoxForEachBiMain( p, iBox, iTerm, i )
491 Vec_IntPush( vBits, Bac_BoxBiRange(p, iTerm) );
492 // iterate through outputs
493 Bac_BoxForEachBoMain( p, iBox, iTerm, i )
494 Vec_IntPush( vBits, Bac_BoxBoRange(p, iTerm) );
495 assert( Vec_IntSize(vBits) < 10 );
496 //Vec_IntPrint( vBits );
497 return vBits;
498}
499
511static inline void Vec_StrPrint( Vec_Str_t * p, int fInt )
512{
513 int i;
514 for ( i = 0; i < p->nSize; i++ )
515 if ( fInt )
516 printf( "%d ", (int)p->pArray[i] );
517 else
518 printf( "%c ", p->pArray[i] );
519 printf( "\n" );
520}
521
533static inline void Bac_NtkAlloc( Bac_Ntk_t * pNew, int NameId, int nIns, int nOuts, int nObjs )
534{
535 int NtkId, fFound;
536 assert( pNew->pDesign != NULL );
537 assert( Bac_NtkPiNum(pNew) == 0 );
538 assert( Bac_NtkPoNum(pNew) == 0 );
539 pNew->NameId = NameId;
540 pNew->iCopy = -1;
541 pNew->iBoxNtk = -1;
542 pNew->iBoxObj = -1;
543 Vec_IntGrow( &pNew->vInputs, nIns );
544 Vec_IntGrow( &pNew->vOutputs, nOuts );
545 Vec_StrGrow( &pNew->vType, nObjs );
546 Vec_IntGrow( &pNew->vFanin, nObjs );
547 // check if the network is unique
548 NtkId = Abc_NamStrFindOrAdd( pNew->pDesign->pMods, Bac_NtkStr(pNew, NameId), &fFound );
549 if ( fFound )
550 printf( "Network with name %s already exists.\n", Bac_NtkStr(pNew, NameId) );
551 else
552 assert( NtkId == Bac_NtkId(pNew) );
553}
554static inline void Bac_NtkDup( Bac_Ntk_t * pNew, Bac_Ntk_t * p )
555{
556 int i, iObj;
557 assert( pNew != p );
558 Bac_NtkAlloc( pNew, Bac_NtkNameId(p), Bac_NtkPiNum(p), Bac_NtkPoNum(p), Bac_NtkObjNum(p) );
559 if ( Vec_IntSize(&p->vInfo) )
560 Vec_IntAppend( &pNew->vInfo, &p->vInfo );
561 Bac_NtkStartCopies( p );
562 if ( Bac_NtkHasNames(p) )
563 Bac_NtkStartNames( pNew );
564 Bac_NtkForEachPi( p, iObj, i )
565 Bac_ObjDup( pNew, p, iObj );
566 Bac_NtkForEachBox( p, iObj )
567 Bac_BoxDup( pNew, p, iObj );
568 Bac_NtkForEachPo( p, iObj, i )
569 Bac_ObjDup( pNew, p, iObj );
570 Bac_NtkForEachCo( p, iObj )
571 Bac_ObjSetFanin( pNew, Bac_ObjCopy(p, iObj), Bac_ObjCopy(p, Bac_ObjFanin(p, iObj)) );
572 //Bac_NtkFreeCopies( p ); // needed for name transfer and host ntk
573 assert( Bac_NtkObjNum(pNew) == Bac_NtkObjNumAlloc(pNew) );
574}
575static inline void Bac_NtkDupUserBoxes( Bac_Ntk_t * pNew, Bac_Ntk_t * p )
576{
577 int i, iObj;
578 assert( pNew != p );
579 Bac_NtkAlloc( pNew, Bac_NtkNameId(p), Bac_NtkPiNum(p), Bac_NtkPoNum(p), Bac_NtkObjNum(p) + 3*Bac_NtkCoNum(p) );
580 if ( Vec_IntSize(&p->vInfo) )
581 Vec_IntAppend( &pNew->vInfo, &p->vInfo );
582 Bac_NtkStartCopies( p );
583 Bac_NtkForEachPi( p, iObj, i )
584 Bac_ObjDup( pNew, p, iObj );
585 Bac_NtkForEachPo( p, iObj, i )
586 Bac_ObjDup( pNew, p, iObj );
587 Bac_NtkForEachBoxUser( p, iObj )
588 Bac_BoxDup( pNew, p, iObj );
589 // connect feed-throughs
590 Bac_NtkForEachCo( p, iObj )
591 if ( Bac_ObjCopy(p, iObj) >= 0 && Bac_ObjCopy(p, Bac_ObjFanin(p, iObj)) >= 0 )
592 Bac_ObjSetFanin( pNew, Bac_ObjCopy(p, iObj), Bac_ObjCopy(p, Bac_ObjFanin(p, iObj)) );
593}
594static inline void Bac_NtkMoveNames( Bac_Ntk_t * pNew, Bac_Ntk_t * p )
595{
596 int i, iBox, iObj;
597 assert( Bac_NtkHasNames(p) );
598 assert( !Bac_NtkHasNames(pNew) );
599 Bac_NtkStartNames( pNew );
600 Bac_NtkForEachPi( p, iObj, i )
601 Bac_ObjSetName( pNew, Bac_ObjCopy(p, iObj), Bac_ObjName(p, iObj) );
602 Bac_NtkForEachBoxUser( p, iBox )
603 {
604 Bac_ObjSetName( pNew, Bac_ObjCopy(p, iBox), Bac_ObjName(p, iBox) );
605 Bac_BoxForEachBo( p, iBox, iObj, i )
606 Bac_ObjSetName( pNew, Bac_ObjCopy(p, iObj), Bac_ObjName(p, iObj) );
607 }
608 Bac_NtkForEachBoxUser( p, iBox )
609 Bac_BoxForEachBi( p, iBox, iObj, i )
610 if ( !Bac_ObjName(pNew, Bac_ObjFanin(pNew, Bac_ObjCopy(p, iObj))) )
611 Bac_ObjSetName( pNew, Bac_ObjFanin(pNew, Bac_ObjCopy(p, iObj)), Bac_ObjName(p, iObj) );
612 Bac_NtkForEachPo( p, iObj, i )
613 if ( !Bac_ObjName(pNew, Bac_ObjFanin(pNew, Bac_ObjCopy(p, iObj))) )
614 Bac_ObjSetName( pNew, Bac_ObjFanin(pNew, Bac_ObjCopy(p, iObj)), Bac_ObjName(p, iObj) );
615}
616
617static inline void Bac_NtkFree( Bac_Ntk_t * p )
618{
619 Vec_IntErase( &p->vInputs );
620 Vec_IntErase( &p->vOutputs );
621 Vec_IntErase( &p->vInfo );
622 Vec_StrErase( &p->vType );
623 Vec_IntErase( &p->vFanin );
624 Vec_IntErase( &p->vIndex );
625 Vec_IntErase( &p->vName );
626 Vec_IntErase( &p->vFanout );
627 Vec_IntErase( &p->vCopy );
628 Vec_IntErase( &p->vArray );
629 Vec_IntErase( &p->vArray2 );
630}
631static inline int Bac_NtkMemory( Bac_Ntk_t * p )
632{
633 int nMem = sizeof(Bac_Ntk_t);
634 nMem += (int)Vec_IntMemory(&p->vInputs);
635 nMem += (int)Vec_IntMemory(&p->vOutputs);
636 nMem += (int)Vec_IntMemory(&p->vInfo);
637 nMem += (int)Vec_StrMemory(&p->vType);
638 nMem += (int)Vec_IntMemory(&p->vFanin);
639 nMem += (int)Vec_IntMemory(&p->vIndex);
640 nMem += (int)Vec_IntMemory(&p->vName);
641 nMem += (int)Vec_IntMemory(&p->vFanout);
642 nMem += (int)Vec_IntMemory(&p->vCopy);
643 return nMem;
644}
645static inline void Bac_NtkPrintStats( Bac_Ntk_t * p )
646{
647 printf( "pi =%5d ", Bac_NtkPiNum(p) );
648 printf( "pi =%5d ", Bac_NtkPoNum(p) );
649 printf( "box =%6d ", Bac_NtkBoxNum(p) );
650 printf( "clp =%7d ", p->Count );
651 printf( "obj =%7d ", Bac_NtkObjNum(p) );
652 printf( "%s ", Bac_NtkName(p) );
653 if ( Bac_NtkHostNtk(p) )
654 printf( "-> %s", Bac_NtkName(Bac_NtkHostNtk(p)) );
655 printf( "\n" );
656}
657static inline void Bac_NtkDeriveIndex( Bac_Ntk_t * p )
658{
659 int i, iObj, iTerm;
660 Vec_IntFill( &p->vIndex, Bac_NtkObjNum(p), -1 );
661 Bac_NtkForEachPi( p, iObj, i )
662 Bac_ObjSetIndex( p, iObj, i );
663 Bac_NtkForEachPo( p, iObj, i )
664 Bac_ObjSetIndex( p, iObj, i );
665 Bac_NtkForEachBox( p, iObj )
666 {
667 Bac_BoxForEachBi( p, iObj, iTerm, i )
668 Bac_ObjSetIndex( p, iTerm, i );
669 Bac_BoxForEachBo( p, iObj, iTerm, i )
670 Bac_ObjSetIndex( p, iTerm, i );
671 }
672}
673static inline void Bac_NtkPrint( Bac_Ntk_t * p )
674{
675 int i, Type, Value, Beg, End;
676 printf( "Interface (%d):\n", Bac_NtkInfoNum(p) );
677 Vec_IntForEachEntryTriple( &p->vInfo, Value, Beg, End, i )
678 {
679 printf( "%6d : ", i );
680 printf( "Type =%3d ", Bac_NtkInfoType(p, i/3) );
681 if ( Beg >= 0 )
682 printf( "[%d:%d] ", End, Beg );
683 else
684 printf( " " );
685 printf( "Name =%3d ", Bac_NtkInfoName(p, i/3) );
686 if ( Bac_NtkInfoName(p, i/3) )
687 printf( "%s", Bac_NtkStr( p, Bac_NtkInfoName(p, i/3) ) );
688 printf( "\n" );
689 }
690 printf( "Objects (%d):\n", Bac_NtkObjNum(p) );
691 Bac_NtkForEachObjType( p, Type, i )
692 {
693 printf( "%6d : ", i );
694 printf( "Type =%3d ", Type );
695 if ( Bac_ObjIsCo(p, i) )
696 printf( "Fanin =%6d ", Bac_ObjFanin(p, i) );
697 else if ( Bac_NtkHasNames(p) && Bac_ObjName(p, i) )
698 {
699 printf( "Name =%6d(%d) ", Bac_ObjNameId(p, i), Bac_ObjNameType(p, i) );
700 if ( Bac_ObjNameType(p, i) <= BAC_NAME_WORD )
701 printf( "%s", Bac_ObjNameStr(p, i) );
702 }
703 printf( "\n" );
704 }
705}
706
707
719static inline Bac_Man_t * Bac_ManAlloc( char * pFileName, int nNtks )
720{
721 extern void Bac_ManSetupTypes( char ** pNames, char ** pSymbs );
722 Bac_Ntk_t * pNtk; int i;
723 Bac_Man_t * pNew = ABC_CALLOC( Bac_Man_t, 1 );
724 pNew->pName = Extra_FileDesignName( pFileName );
725 pNew->pSpec = Abc_UtilStrsav( pFileName );
726 pNew->pStrs = Abc_NamStart( 1000, 24 );
727 pNew->pMods = Abc_NamStart( 1000, 24 );
728 pNew->iRoot = 1;
729 pNew->nNtks = nNtks;
730 pNew->pNtks = ABC_CALLOC( Bac_Ntk_t, pNew->nNtks + 1 );
731 Bac_ManForEachNtk( pNew, pNtk, i )
732 pNtk->pDesign = pNew;
733 Bac_ManSetupTypes( pNew->pPrimNames, pNew->pPrimSymbs );
734 return pNew;
735}
736static inline Bac_Man_t * Bac_ManStart( Bac_Man_t * p, int nNtks )
737{
738 Bac_Ntk_t * pNtk; int i;
739 Bac_Man_t * pNew = ABC_CALLOC( Bac_Man_t, 1 );
740 pNew->pName = Abc_UtilStrsav( Bac_ManName(p) );
741 pNew->pSpec = Abc_UtilStrsav( Bac_ManSpec(p) );
742 pNew->pStrs = Abc_NamRef( p->pStrs );
743 pNew->pMods = Abc_NamStart( 1000, 24 );
744 pNew->iRoot = 1;
745 pNew->nNtks = nNtks;
746 pNew->pNtks = ABC_CALLOC( Bac_Ntk_t, nNtks + 1 );
747 Bac_ManForEachNtk( pNew, pNtk, i )
748 pNtk->pDesign = pNew;
749 return pNew;
750}
751static inline Bac_Man_t * Bac_ManDup( Bac_Man_t * p )
752{
753 Bac_Ntk_t * pNtk, * pHost; int i;
754 Bac_Man_t * pNew = Bac_ManStart( p, Bac_ManNtkNum(p) );
755 Bac_ManForEachNtk( p, pNtk, i )
756 Bac_NtkSetCopy( pNtk, i );
757 Bac_ManForEachNtk( p, pNtk, i )
758 Bac_NtkDup( Bac_NtkCopyNtk(pNew, pNtk), pNtk );
759 Bac_ManForEachNtk( p, pNtk, i )
760 if ( (pHost = Bac_NtkHostNtk(pNtk)) )
761 Bac_NtkSetHost( Bac_NtkCopyNtk(pNew, pNtk), Bac_NtkCopy(pHost), Bac_ObjCopy(pHost, Bac_NtkHostObj(pNtk)) );
762 return pNew;
763}
764static inline Bac_Man_t * Bac_ManDupUserBoxes( Bac_Man_t * p )
765{
766 Bac_Ntk_t * pNtk, * pHost; int i;
767 Bac_Man_t * pNew = Bac_ManStart( p, Bac_ManNtkNum(p) );
768 Bac_ManForEachNtk( p, pNtk, i )
769 Bac_NtkSetCopy( pNtk, i );
770 Bac_ManForEachNtk( p, pNtk, i )
771 Bac_NtkDupUserBoxes( Bac_NtkCopyNtk(pNew, pNtk), pNtk );
772 Bac_ManForEachNtk( p, pNtk, i )
773 if ( (pHost = Bac_NtkHostNtk(pNtk)) )
774 Bac_NtkSetHost( Bac_NtkCopyNtk(pNew, pNtk), Bac_NtkCopy(pHost), Bac_ObjCopy(pHost, Bac_NtkHostObj(pNtk)) );
775 return pNew;
776}
777static inline void Bac_ManMoveNames( Bac_Man_t * pNew, Bac_Man_t * p )
778{
779 Bac_Ntk_t * pNtk; int i;
780 Bac_ManForEachNtk( p, pNtk, i )
781 Bac_NtkMoveNames( Bac_NtkCopyNtk(pNew, pNtk), pNtk );
782}
783
784
785static inline void Bac_ManFree( Bac_Man_t * p )
786{
787 Bac_Ntk_t * pNtk; int i;
788 Bac_ManForEachNtk( p, pNtk, i )
789 Bac_NtkFree( pNtk );
790 Vec_IntErase( &p->vBuf2LeafNtk );
791 Vec_IntErase( &p->vBuf2LeafObj );
792 Vec_IntErase( &p->vBuf2RootNtk );
793 Vec_IntErase( &p->vBuf2RootObj );
794 Abc_NamDeref( p->pStrs );
795 Abc_NamDeref( p->pMods );
796 ABC_FREE( p->pName );
797 ABC_FREE( p->pSpec );
798 ABC_FREE( p->pNtks );
799 ABC_FREE( p );
800}
801static inline int Bac_ManMemory( Bac_Man_t * p )
802{
803 Bac_Ntk_t * pNtk; int i;
804 int nMem = sizeof(Bac_Man_t);
805 if ( p->pName )
806 nMem += (int)strlen(p->pName);
807 if ( p->pSpec )
808 nMem += (int)strlen(p->pSpec);
809 nMem += Abc_NamMemUsed(p->pStrs);
810 nMem += Abc_NamMemUsed(p->pMods);
811 Bac_ManForEachNtk( p, pNtk, i )
812 nMem += Bac_NtkMemory( pNtk );
813 return nMem;
814}
815static inline int Bac_ManObjNum( Bac_Man_t * p )
816{
817 Bac_Ntk_t * pNtk; int i, Count = 0;
818 Bac_ManForEachNtk( p, pNtk, i )
819 Count += Bac_NtkObjNum(pNtk);
820 return Count;
821}
822static inline int Bac_ManNodeNum( Bac_Man_t * p )
823{
824 Bac_Ntk_t * pNtk; int i, Count = 0;
825 Bac_ManForEachNtk( p, pNtk, i )
826 Count += Bac_NtkBoxNum( pNtk );
827 return Count;
828}
829static inline int Bac_ManBoxNum_rec( Bac_Ntk_t * p )
830{
831 int iObj, Counter = 0;
832 if ( p->Count >= 0 )
833 return p->Count;
834 Bac_NtkForEachBox( p, iObj )
835 Counter += Bac_ObjIsBoxUser(p, iObj) ? Bac_ManBoxNum_rec( Bac_BoxNtk(p, iObj) ) : 1;
836 return (p->Count = Counter);
837}
838static inline int Bac_ManBoxNum( Bac_Man_t * p )
839{
840 Bac_Ntk_t * pNtk; int i;
841 Bac_ManForEachNtk( p, pNtk, i )
842 pNtk->Count = -1;
843 return Bac_ManBoxNum_rec( Bac_ManRoot(p) );
844}
845static inline void Bac_ManPrintStats( Bac_Man_t * p, int nModules, int fVerbose )
846{
847 Bac_Ntk_t * pNtk; int i;
848 Bac_Ntk_t * pRoot = Bac_ManRoot( p );
849 printf( "%-12s : ", Bac_ManName(p) );
850 printf( "pi =%5d ", Bac_NtkPiNum(pRoot) );
851 printf( "po =%5d ", Bac_NtkPoNum(pRoot) );
852 printf( "pri =%4d ", Bac_ManPrimNum(p) );
853 printf( "mod =%6d ", Bac_ManNtkNum(p) );
854 printf( "box =%7d ", Bac_ManNodeNum(p) );
855 printf( "obj =%7d ", Bac_ManObjNum(p) );
856 printf( "mem =%6.3f MB", 1.0*Bac_ManMemory(p)/(1<<20) );
857 printf( "\n" );
858 Bac_ManBoxNum( p );
859 Bac_ManForEachNtk( p, pNtk, i )
860 {
861 if ( i == nModules+1 )
862 break;
863 printf( "Module %5d : ", i );
864 Bac_NtkPrintStats( pNtk );
865 }
866}
867
868
869
881static inline Bac_ObjType_t Ptr_SopToType( char * pSop )
882{
883 if ( !strcmp(pSop, " 0\n") ) return BAC_BOX_CF;
884 if ( !strcmp(pSop, " 1\n") ) return BAC_BOX_CT;
885 if ( !strcmp(pSop, "1 1\n") ) return BAC_BOX_BUF;
886 if ( !strcmp(pSop, "0 1\n") ) return BAC_BOX_INV;
887 if ( !strcmp(pSop, "11 1\n") ) return BAC_BOX_AND;
888 if ( !strcmp(pSop, "00 1\n") ) return BAC_BOX_NOR;
889 if ( !strcmp(pSop, "00 0\n") ) return BAC_BOX_OR;
890 if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return BAC_BOX_OR;
891 if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return BAC_BOX_OR;
892 if ( !strcmp(pSop, "01 1\n10 1\n") ) return BAC_BOX_XOR;
893 if ( !strcmp(pSop, "10 1\n01 1\n") ) return BAC_BOX_XOR;
894 if ( !strcmp(pSop, "11 1\n00 1\n") ) return BAC_BOX_XNOR;
895 if ( !strcmp(pSop, "00 1\n11 1\n") ) return BAC_BOX_XNOR;
896 if ( !strcmp(pSop, "10 1\n") ) return BAC_BOX_SHARP;
897 if ( !strcmp(pSop, "01 1\n") ) return BAC_BOX_SHARPL;
898 assert( 0 );
899 return BAC_OBJ_NONE;
900}
901static inline char * Ptr_SopToTypeName( char * pSop )
902{
903 if ( !strcmp(pSop, " 0\n") ) return "BAC_BOX_C0";
904 if ( !strcmp(pSop, " 1\n") ) return "BAC_BOX_C1";
905 if ( !strcmp(pSop, "1 1\n") ) return "BAC_BOX_BUF";
906 if ( !strcmp(pSop, "0 1\n") ) return "BAC_BOX_INV";
907 if ( !strcmp(pSop, "11 1\n") ) return "BAC_BOX_AND";
908 if ( !strcmp(pSop, "00 1\n") ) return "BAC_BOX_NOR";
909 if ( !strcmp(pSop, "00 0\n") ) return "BAC_BOX_OR";
910 if ( !strcmp(pSop, "-1 1\n1- 1\n") ) return "BAC_BOX_OR";
911 if ( !strcmp(pSop, "1- 1\n-1 1\n") ) return "BAC_BOX_OR";
912 if ( !strcmp(pSop, "01 1\n10 1\n") ) return "BAC_BOX_XOR";
913 if ( !strcmp(pSop, "10 1\n01 1\n") ) return "BAC_BOX_XOR";
914 if ( !strcmp(pSop, "11 1\n00 1\n") ) return "BAC_BOX_XNOR";
915 if ( !strcmp(pSop, "00 1\n11 1\n") ) return "BAC_BOX_XNOR";
916 if ( !strcmp(pSop, "10 1\n") ) return "BAC_BOX_SHARP";
917 if ( !strcmp(pSop, "01 1\n") ) return "BAC_BOX_SHARPL";
918 assert( 0 );
919 return NULL;
920}
921static inline char * Ptr_TypeToName( Bac_ObjType_t Type )
922{
923 if ( Type == BAC_BOX_CF ) return "const0";
924 if ( Type == BAC_BOX_CT ) return "const1";
925 if ( Type == BAC_BOX_CX ) return "constX";
926 if ( Type == BAC_BOX_CZ ) return "constZ";
927 if ( Type == BAC_BOX_BUF ) return "buf";
928 if ( Type == BAC_BOX_INV ) return "not";
929 if ( Type == BAC_BOX_AND ) return "and";
930 if ( Type == BAC_BOX_NAND ) return "nand";
931 if ( Type == BAC_BOX_OR ) return "or";
932 if ( Type == BAC_BOX_NOR ) return "nor";
933 if ( Type == BAC_BOX_XOR ) return "xor";
934 if ( Type == BAC_BOX_XNOR ) return "xnor";
935 if ( Type == BAC_BOX_MUX ) return "mux";
936 if ( Type == BAC_BOX_MAJ ) return "maj";
937 if ( Type == BAC_BOX_SHARP ) return "sharp";
938 if ( Type == BAC_BOX_SHARPL) return "sharpl";
939 assert( 0 );
940 return "???";
941}
942static inline char * Ptr_TypeToSop( Bac_ObjType_t Type )
943{
944 if ( Type == BAC_BOX_CF ) return " 0\n";
945 if ( Type == BAC_BOX_CT ) return " 1\n";
946 if ( Type == BAC_BOX_CX ) return " 0\n";
947 if ( Type == BAC_BOX_CZ ) return " 0\n";
948 if ( Type == BAC_BOX_BUF ) return "1 1\n";
949 if ( Type == BAC_BOX_INV ) return "0 1\n";
950 if ( Type == BAC_BOX_AND ) return "11 1\n";
951 if ( Type == BAC_BOX_NAND ) return "11 0\n";
952 if ( Type == BAC_BOX_OR ) return "00 0\n";
953 if ( Type == BAC_BOX_NOR ) return "00 1\n";
954 if ( Type == BAC_BOX_XOR ) return "01 1\n10 1\n";
955 if ( Type == BAC_BOX_XNOR ) return "00 1\n11 1\n";
956 if ( Type == BAC_BOX_SHARP ) return "10 1\n";
957 if ( Type == BAC_BOX_SHARPL) return "01 1\n";
958 if ( Type == BAC_BOX_MUX ) return "11- 1\n0-1 1\n";
959 if ( Type == BAC_BOX_MAJ ) return "11- 1\n1-1 1\n-11 1\n";
960 assert( 0 );
961 return "???";
962}
963
964/*=== bacCom.c ===============================================================*/
965extern void Abc_FrameImportPtr( Vec_Ptr_t * vPtr );
966extern Vec_Ptr_t * Abc_FrameExportPtr();
967
968/*=== bacBlast.c =============================================================*/
969extern int Bac_NtkBuildLibrary( Bac_Man_t * p );
970extern Gia_Man_t * Bac_ManExtract( Bac_Man_t * p, int fBuffers, int fVerbose );
971extern Bac_Man_t * Bac_ManInsertGia( Bac_Man_t * p, Gia_Man_t * pGia );
972extern void * Bac_ManInsertAbc( Bac_Man_t * p, void * pAbc );
973/*=== bacCba.c ===============================================================*/
974extern Bac_Man_t * Bac_ManReadBac( char * pFileName );
975extern void Bac_ManWriteBac( char * pFileName, Bac_Man_t * p );
976/*=== bacNtk.c ===============================================================*/
977extern char * Bac_NtkGenerateName( Bac_Ntk_t * p, Bac_ObjType_t Type, Vec_Int_t * vBits );
978extern Bac_ObjType_t Bac_NameToType( char * pName );
979extern Vec_Int_t * Bac_NameToRanges( char * pName );
980extern void Bac_NtkUpdateFanout( Bac_Ntk_t * p, int iOld, int iNew );
981extern void Bac_ManDeriveFanout( Bac_Man_t * p );
982//extern void Bac_ManAssignInternNames( Bac_Man_t * p );
983extern void Bac_ManAssignInternWordNames( Bac_Man_t * p );
984extern Bac_Man_t * Bac_ManCollapse( Bac_Man_t * p );
985extern void Bac_ManSetupTypes( char ** pNames, char ** pSymbs );
986/*=== bacPtr.c ===============================================================*/
987extern void Bac_PtrFree( Vec_Ptr_t * vDes );
988extern int Bac_PtrMemory( Vec_Ptr_t * vDes );
989extern void Bac_PtrDumpBlif( char * pFileName, Vec_Ptr_t * vDes );
990extern void Bac_PtrDumpVerilog( char * pFileName, Vec_Ptr_t * vDes );
991extern Vec_Ptr_t * Bac_PtrTransformTest( Vec_Ptr_t * vDes );
992/*=== bacPtrAbc.c ============================================================*/
993extern Bac_Man_t * Bac_PtrTransformToCba( Vec_Ptr_t * vDes );
994extern Vec_Ptr_t * Bac_PtrDeriveFromCba( Bac_Man_t * p );
995/*=== bacPrsBuild.c ==========================================================*/
996extern Bac_Man_t * Psr_ManBuildCba( char * pFileName, Vec_Ptr_t * vDes );
997/*=== bacReadBlif.c ==========================================================*/
998extern Vec_Ptr_t * Psr_ManReadBlif( char * pFileName );
999/*=== bacReadSmt.c ===========================================================*/
1000extern Vec_Ptr_t * Psr_ManReadSmt( char * pFileName );
1001/*=== bacReadVer.c ===========================================================*/
1002extern Vec_Ptr_t * Psr_ManReadVerilog( char * pFileName );
1003/*=== bacWriteBlif.c =========================================================*/
1004extern void Psr_ManWriteBlif( char * pFileName, Vec_Ptr_t * p );
1005extern void Bac_ManWriteBlif( char * pFileName, Bac_Man_t * p );
1006/*=== bacWriteVer.c ==========================================================*/
1007extern void Psr_ManWriteVerilog( char * pFileName, Vec_Ptr_t * p );
1008extern void Bac_ManWriteVerilog( char * pFileName, Bac_Man_t * p, int fUseAssign );
1009
1010ABC_NAMESPACE_HEADER_END
1011
1012#endif
1013
1017
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
Bac_NtkForEachObjType
#define Bac_NtkForEachObjType(p, Type, i)
Definition bac.h:351
Bac_PtrFree
void Bac_PtrFree(Vec_Ptr_t *vDes)
Definition bacPtr.c:98
Bac_Man_t
struct Bac_Man_t_ Bac_Man_t
Definition bac.h:142
Bac_ManExtract
Gia_Man_t * Bac_ManExtract(Bac_Man_t *p, int fBuffers, int fVerbose)
Definition bacBlast.c:216
Bac_ManCollapse
Bac_Man_t * Bac_ManCollapse(Bac_Man_t *p)
Definition bacNtk.c:567
Bac_Ntk_t
struct Bac_Ntk_t_ Bac_Ntk_t
Definition bac.h:141
Bac_BoxForEachBo
#define Bac_BoxForEachBo(p, iBox, iTerm, i)
Definition bac.h:377
Bac_NtkGenerateName
char * Bac_NtkGenerateName(Bac_Ntk_t *p, Bac_ObjType_t Type, Vec_Int_t *vBits)
Definition bacNtk.c:142
Bac_BoxForEachBoMain
#define Bac_BoxForEachBoMain(p, iBox, iTerm, i)
Definition bac.h:384
Bac_NtkUpdateFanout
void Bac_NtkUpdateFanout(Bac_Ntk_t *p, int iOld, int iNew)
FUNCTION DEFINITIONS ///.
Definition bacNtk.c:215
Bac_ManDeriveFanout
void Bac_ManDeriveFanout(Bac_Man_t *p)
Definition bacNtk.c:258
Bac_ManInsertGia
Bac_Man_t * Bac_ManInsertGia(Bac_Man_t *p, Gia_Man_t *pGia)
Definition bacBlast.c:399
Bac_NtkForEachCo
#define Bac_NtkForEachCo(p, i)
Definition bac.h:363
Bac_NtkBuildLibrary
int Bac_NtkBuildLibrary(Bac_Man_t *p)
Definition bacBlast.c:509
Bac_NtkForEachPi
#define Bac_NtkForEachPi(p, iObj, i)
Definition bac.h:337
Psr_ManReadSmt
Vec_Ptr_t * Psr_ManReadSmt(char *pFileName)
Abc_FrameImportPtr
void Abc_FrameImportPtr(Vec_Ptr_t *vPtr)
FUNCTION DEFINITIONS ///.
Definition bacCom.c:60
Bac_ManWriteBac
void Bac_ManWriteBac(char *pFileName, Bac_Man_t *p)
Definition bacBac.c:272
Bac_ManWriteBlif
void Bac_ManWriteBlif(char *pFileName, Bac_Man_t *p)
Definition bacWriteBlif.c:205
Bac_NtkForEachBoxUser
#define Bac_NtkForEachBoxUser(p, i)
Definition bac.h:356
Abc_FrameExportPtr
Vec_Ptr_t * Abc_FrameExportPtr()
Definition bacCom.c:73
Bac_ManAssignInternWordNames
void Bac_ManAssignInternWordNames(Bac_Man_t *p)
Definition bacNtk.c:392
Bac_PtrTransformTest
Vec_Ptr_t * Bac_PtrTransformTest(Vec_Ptr_t *vDes)
Definition bacPtr.c:411
Bac_BoxForEachBi
#define Bac_BoxForEachBi(p, iBox, iTerm, i)
Definition bac.h:375
Bac_NameToRanges
Vec_Int_t * Bac_NameToRanges(char *pName)
Definition bacNtk.c:172
Bac_ManReadBac
Bac_Man_t * Bac_ManReadBac(char *pFileName)
Definition bacBac.c:181
Bac_NameType_t
Bac_NameType_t
Definition bac.h:133
BAC_NAME_WORD
@ BAC_NAME_WORD
Definition bac.h:135
BAC_NAME_INFO
@ BAC_NAME_INFO
Definition bac.h:136
BAC_NAME_INDEX
@ BAC_NAME_INDEX
Definition bac.h:137
BAC_NAME_BIN
@ BAC_NAME_BIN
Definition bac.h:134
Bac_PtrMemory
int Bac_PtrMemory(Vec_Ptr_t *vDes)
Definition bacPtr.c:138
Bac_NameToType
Bac_ObjType_t Bac_NameToType(char *pName)
Definition bacNtk.c:161
Psr_ManReadVerilog
Vec_Ptr_t * Psr_ManReadVerilog(char *pFileName)
Definition bacReadVer.c:834
Bac_PtrDumpVerilog
void Bac_PtrDumpVerilog(char *pFileName, Vec_Ptr_t *vDes)
Definition bacPtr.c:256
Bac_PtrTransformToCba
Bac_Man_t * Bac_PtrTransformToCba(Vec_Ptr_t *vDes)
Definition bacPtrAbc.c:355
Bac_NtkForEachPo
#define Bac_NtkForEachPo(p, iObj, i)
Definition bac.h:339
Bac_BoxForEachBiReverse
#define Bac_BoxForEachBiReverse(p, iBox, iTerm, i)
Definition bac.h:379
Bac_PtrDumpBlif
void Bac_PtrDumpBlif(char *pFileName, Vec_Ptr_t *vDes)
Definition bacPtr.c:192
Bac_ManForEachNtk
#define Bac_ManForEachNtk(p, pNtk, i)
MACRO DEFINITIONS ///.
Definition bac.h:334
Psr_ManWriteBlif
void Psr_ManWriteBlif(char *pFileName, Vec_Ptr_t *p)
Definition bacWriteBlif.c:103
Bac_NtkForEachBox
#define Bac_NtkForEachBox(p, i)
Definition bac.h:354
Bac_BoxForEachBiMain
#define Bac_BoxForEachBiMain(p, iBox, iTerm, i)
Definition bac.h:382
Psr_ManBuildCba
Bac_Man_t * Psr_ManBuildCba(char *pFileName, Vec_Ptr_t *vDes)
Definition bacPrsBuild.c:328
Bac_ManInsertAbc
void * Bac_ManInsertAbc(Bac_Man_t *p, void *pAbc)
Definition bacBlast.c:570
Bac_ManSetupTypes
void Bac_ManSetupTypes(char **pNames, char **pSymbs)
Definition bacNtk.c:131
Psr_ManWriteVerilog
void Psr_ManWriteVerilog(char *pFileName, Vec_Ptr_t *p)
Definition bacWriteVer.c:166
Bac_ObjType_t
Bac_ObjType_t
INCLUDES ///.
Definition bac.h:43
BAC_BOX_SHIR
@ BAC_BOX_SHIR
Definition bac.h:108
BAC_BOX_DFFRS
@ BAC_BOX_DFFRS
Definition bac.h:126
BAC_BOX_ROR
@ BAC_BOX_ROR
Definition bac.h:70
BAC_BOX_UNKNOWN
@ BAC_BOX_UNKNOWN
Definition bac.h:128
BAC_BOX_ASSIGN
@ BAC_BOX_ASSIGN
Definition bac.h:114
BAC_BOX_RAMWC
@ BAC_BOX_RAMWC
Definition bac.h:120
BAC_BOX_SHARP
@ BAC_BOX_SHARP
Definition bac.h:63
BAC_BOX_MIN
@ BAC_BOX_MIN
Definition bac.h:97
BAC_BOX_ROTL
@ BAC_BOX_ROTL
Definition bac.h:109
BAC_BOX_MUL
@ BAC_BOX_MUL
Definition bac.h:92
BAC_BOX_LATCH
@ BAC_BOX_LATCH
Definition bac.h:123
BAC_BOX_XNOR
@ BAC_BOX_XNOR
Definition bac.h:62
BAC_BOX_AND
@ BAC_BOX_AND
Definition bac.h:57
BAC_BOX_RAND
@ BAC_BOX_RAND
Definition bac.h:68
BAC_BOX_INV
@ BAC_BOX_INV
Definition bac.h:56
BAC_BOX_PSEL
@ BAC_BOX_PSEL
Definition bac.h:84
BAC_BOX_PENC
@ BAC_BOX_PENC
Definition bac.h:86
BAC_BOX_TRI
@ BAC_BOX_TRI
Definition bac.h:116
BAC_BOX_LUT
@ BAC_BOX_LUT
Definition bac.h:113
BAC_BOX_RXOR
@ BAC_BOX_RXOR
Definition bac.h:72
BAC_BOX_EDEC
@ BAC_BOX_EDEC
Definition bac.h:88
BAC_BOX_SHIL
@ BAC_BOX_SHIL
Definition bac.h:107
BAC_BOX_LNOR
@ BAC_BOX_LNOR
Definition bac.h:78
BAC_BOX_RNOR
@ BAC_BOX_RNOR
Definition bac.h:71
BAC_BOX_LATCHRS
@ BAC_BOX_LATCHRS
Definition bac.h:124
BAC_BOX_SEL
@ BAC_BOX_SEL
Definition bac.h:83
BAC_BOX_ADD
@ BAC_BOX_ADD
Definition bac.h:90
BAC_BOX_MAJ
@ BAC_BOX_MAJ
Definition bac.h:66
BAC_BOX_NMUX
@ BAC_BOX_NMUX
Definition bac.h:82
BAC_OBJ_PO
@ BAC_OBJ_PO
Definition bac.h:46
BAC_BOX_CT
@ BAC_BOX_CT
Definition bac.h:52
BAC_BOX_DIV
@ BAC_BOX_DIV
Definition bac.h:93
BAC_BOX_RXNOR
@ BAC_BOX_RXNOR
Definition bac.h:73
BAC_BOX_CX
@ BAC_BOX_CX
Definition bac.h:53
BAC_BOX_ROTR
@ BAC_BOX_ROTR
Definition bac.h:110
BAC_BOX_DEC
@ BAC_BOX_DEC
Definition bac.h:87
BAC_BOX_BUF
@ BAC_BOX_BUF
Definition bac.h:55
BAC_BOX_MTHAN
@ BAC_BOX_MTHAN
Definition bac.h:103
BAC_BOX_REM
@ BAC_BOX_REM
Definition bac.h:95
BAC_OBJ_BI
@ BAC_OBJ_BI
Definition bac.h:47
BAC_BOX_LAND
@ BAC_BOX_LAND
Definition bac.h:75
BAC_BOX_ENC
@ BAC_BOX_ENC
Definition bac.h:85
BAC_BOX_CF
@ BAC_BOX_CF
Definition bac.h:51
BAC_OBJ_NONE
@ BAC_OBJ_NONE
Definition bac.h:44
BAC_BOX_RAMR
@ BAC_BOX_RAMR
Definition bac.h:118
BAC_BOX_XOR
@ BAC_BOX_XOR
Definition bac.h:61
BAC_BOX_MUX
@ BAC_BOX_MUX
Definition bac.h:65
BAC_OBJ_BO
@ BAC_OBJ_BO
Definition bac.h:48
BAC_BOX_GATE
@ BAC_BOX_GATE
Definition bac.h:112
BAC_BOX_DFF
@ BAC_BOX_DFF
Definition bac.h:125
BAC_BOX_RAMBOX
@ BAC_BOX_RAMBOX
Definition bac.h:121
BAC_BOX_OR
@ BAC_BOX_OR
Definition bac.h:59
BAC_BOX_RAMW
@ BAC_BOX_RAMW
Definition bac.h:119
BAC_BOX_LETHAN
@ BAC_BOX_LETHAN
Definition bac.h:101
BAC_BOX_NAND
@ BAC_BOX_NAND
Definition bac.h:58
BAC_BOX_LTHAN
@ BAC_BOX_LTHAN
Definition bac.h:100
BAC_BOX_SHARPL
@ BAC_BOX_SHARPL
Definition bac.h:64
BAC_BOX_CZ
@ BAC_BOX_CZ
Definition bac.h:54
BAC_OBJ_PI
@ BAC_OBJ_PI
Definition bac.h:45
BAC_BOX_POW
@ BAC_BOX_POW
Definition bac.h:96
BAC_BOX_LXNOR
@ BAC_BOX_LXNOR
Definition bac.h:80
BAC_BOX_RNAND
@ BAC_BOX_RNAND
Definition bac.h:69
BAC_BOX_NEQU
@ BAC_BOX_NEQU
Definition bac.h:105
BAC_BOX_METHAN
@ BAC_BOX_METHAN
Definition bac.h:102
BAC_BOX_RAM
@ BAC_BOX_RAM
Definition bac.h:117
BAC_BOX_EQU
@ BAC_BOX_EQU
Definition bac.h:104
BAC_BOX_ABS
@ BAC_BOX_ABS
Definition bac.h:98
BAC_BOX_NOR
@ BAC_BOX_NOR
Definition bac.h:60
BAC_BOX_SUB
@ BAC_BOX_SUB
Definition bac.h:91
BAC_BOX_LXOR
@ BAC_BOX_LXOR
Definition bac.h:79
BAC_BOX_MOD
@ BAC_BOX_MOD
Definition bac.h:94
BAC_BOX_LNAND
@ BAC_BOX_LNAND
Definition bac.h:76
BAC_OBJ_BOX
@ BAC_OBJ_BOX
Definition bac.h:49
BAC_BOX_LOR
@ BAC_BOX_LOR
Definition bac.h:77
Psr_ManReadBlif
Vec_Ptr_t * Psr_ManReadBlif(char *pFileName)
Definition bacReadBlif.c:406
Bac_ManWriteVerilog
void Bac_ManWriteVerilog(char *pFileName, Bac_Man_t *p, int fUseAssign)
Definition bacWriteVer.c:660
Bac_PtrDeriveFromCba
Vec_Ptr_t * Bac_PtrDeriveFromCba(Bac_Man_t *p)
Definition bacPtrAbc.c:459
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
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
Bac_Man_t_
Definition bac.h:172
Bac_Man_t_::pStrs
Abc_Nam_t * pStrs
Definition bac.h:176
Bac_Man_t_::vBuf2LeafObj
Vec_Int_t vBuf2LeafObj
Definition bac.h:188
Bac_Man_t_::vOut
Vec_Str_t * vOut
Definition bac.h:183
Bac_Man_t_::vBuf2LeafNtk
Vec_Int_t vBuf2LeafNtk
Definition bac.h:187
Bac_Man_t_::vBuf2RootObj
Vec_Int_t vBuf2RootObj
Definition bac.h:186
Bac_Man_t_::pMods
Abc_Nam_t * pMods
Definition bac.h:177
Bac_Man_t_::nNtks
int nNtks
Definition bac.h:180
Bac_Man_t_::pSpec
char * pSpec
Definition bac.h:175
Bac_Man_t_::ppGraphs
void ** ppGraphs
Definition bac.h:190
Bac_Man_t_::ElemGates
int ElemGates[4]
Definition bac.h:191
Bac_Man_t_::vBuf2RootNtk
Vec_Int_t vBuf2RootNtk
Definition bac.h:185
Bac_Man_t_::pPrimNames
char * pPrimNames[BAC_BOX_UNKNOWN]
Definition bac.h:192
Bac_Man_t_::iRoot
int iRoot
Definition bac.h:179
Bac_Man_t_::pNtks
Bac_Ntk_t * pNtks
Definition bac.h:181
Bac_Man_t_::pPrimSymbs
char * pPrimSymbs[BAC_BOX_UNKNOWN]
Definition bac.h:193
Bac_Man_t_::vOut2
Vec_Str_t * vOut2
Definition bac.h:184
Bac_Man_t_::pName
char * pName
Definition bac.h:174
Bac_Man_t_::pMioLib
void * pMioLib
Definition bac.h:189
Bac_Ntk_t_
Definition bac.h:146
Bac_Ntk_t_::vCopy
Vec_Int_t vCopy
Definition bac.h:164
Bac_Ntk_t_::vType
Vec_Str_t vType
Definition bac.h:159
Bac_Ntk_t_::vInfo
Vec_Int_t vInfo
Definition bac.h:157
Bac_Ntk_t_::NameId
int NameId
Definition bac.h:148
Bac_Ntk_t_::vFanout
Vec_Int_t vFanout
Definition bac.h:163
Bac_Ntk_t_::vArray
Vec_Int_t vArray
Definition bac.h:166
Bac_Ntk_t_::Mark
int Mark
Definition bac.h:153
Bac_Ntk_t_::vFanin
Vec_Int_t vFanin
Definition bac.h:160
Bac_Ntk_t_::vIndex
Vec_Int_t vIndex
Definition bac.h:161
Bac_Ntk_t_::iBoxObj
int iBoxObj
Definition bac.h:151
Bac_Ntk_t_::iCopy
int iCopy
Definition bac.h:149
Bac_Ntk_t_::Count
int Count
Definition bac.h:152
Bac_Ntk_t_::pDesign
Bac_Man_t * pDesign
Definition bac.h:147
Bac_Ntk_t_::vName
Vec_Int_t vName
Definition bac.h:162
Bac_Ntk_t_::vOutputs
Vec_Int_t vOutputs
Definition bac.h:156
Bac_Ntk_t_::vArray2
Vec_Int_t vArray2
Definition bac.h:167
Bac_Ntk_t_::iBoxNtk
int iBoxNtk
Definition bac.h:150
Bac_Ntk_t_::vInputs
Vec_Int_t vInputs
Definition bac.h:155
Abc_NamStrFind
int Abc_NamStrFind(Abc_Nam_t *p, char *pStr)
Definition utilNam.c:433
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_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
strlen
int strlen()
strcmp
int strcmp()
Vec_IntForEachEntryTriple
#define Vec_IntForEachEntryTriple(vVec, Entry1, Entry2, Entry3, i)
Definition vecInt.h:76
Vec_Ptr_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Ptr_t_ Vec_Ptr_t
INCLUDES ///.
Definition vecPtr.h:42