1 /**CFile****************************************************************
2
3 FileName [bacPtrAbc.c]
4
5 SystemName [ABC: Logic synthesis and verification system.]
6
7 PackageName [Hierarchical word-level netlist.]
8
9 Synopsis [Simple interface with external tools.]
10
11 Author [Alan Mishchenko]
12
13 Affiliation [UC Berkeley]
14
15 Date [Ver. 1.0. Started - November 29, 2014.]
16
17 Revision [$Id: bacPtrAbc.c,v 1.00 2014/11/29 00:00:00 alanmi Exp $]
18
19 ***********************************************************************/
20
21 #include "bac.h"
22 #include "base/abc/abc.h"
23 #include "map/mio/mio.h"
24 #include "base/main/mainInt.h"
25
26 ABC_NAMESPACE_IMPL_START
27
28 ////////////////////////////////////////////////////////////////////////
29 /// DECLARATIONS ///
30 ////////////////////////////////////////////////////////////////////////
31
32 ////////////////////////////////////////////////////////////////////////
33 /// FUNCTION DEFINITIONS ///
34 ////////////////////////////////////////////////////////////////////////
35
36 /**Function*************************************************************
37
38 Synopsis [Node type conversions.]
39
40 Description []
41
42 SideEffects []
43
44 SeeAlso []
45
46 ***********************************************************************/
Ptr_HopToType(Abc_Obj_t * pObj)47 char * Ptr_HopToType( Abc_Obj_t * pObj )
48 {
49 static word uTruth, uTruths6[3] = {
50 ABC_CONST(0xAAAAAAAAAAAAAAAA),
51 ABC_CONST(0xCCCCCCCCCCCCCCCC),
52 ABC_CONST(0xF0F0F0F0F0F0F0F0),
53 };
54 assert( Abc_ObjIsNode(pObj) );
55 uTruth = Hop_ManComputeTruth6( (Hop_Man_t *)Abc_ObjNtk(pObj)->pManFunc, (Hop_Obj_t *)pObj->pData, Abc_ObjFaninNum(pObj) );
56 /*
57 if ( uTruth == 0 ) return "BAC_BOX_C0";
58 if ( uTruth == ~(word)0 ) return "BAC_BOX_C1";
59 if ( uTruth == uTruths6[0] ) return "BAC_BOX_BUF";
60 if ( uTruth == ~uTruths6[0] ) return "BAC_BOX_INV";
61 if ( uTruth == (uTruths6[0] & uTruths6[1]) ) return "BAC_BOX_AND";
62 if ( uTruth ==~(uTruths6[0] & uTruths6[1]) ) return "BAC_BOX_NAND";
63 if ( uTruth == (uTruths6[0] | uTruths6[1]) ) return "BAC_BOX_OR";
64 if ( uTruth ==~(uTruths6[0] | uTruths6[1]) ) return "BAC_BOX_NOR";
65 if ( uTruth == (uTruths6[0] ^ uTruths6[1]) ) return "BAC_BOX_XOR";
66 if ( uTruth ==~(uTruths6[0] ^ uTruths6[1]) ) return "BAC_BOX_XNOR";
67 */
68 if ( uTruth == 0 ) return "Const0T";
69 if ( uTruth == ~(word)0 ) return "Const1T";
70 if ( uTruth == uTruths6[0] ) return "BufT";
71 if ( uTruth == ~uTruths6[0] ) return "InvT";
72 if ( uTruth == (uTruths6[0] & uTruths6[1]) ) return "AndT";
73 if ( uTruth ==~(uTruths6[0] & uTruths6[1]) ) return "NandT";
74 if ( uTruth == (uTruths6[0] | uTruths6[1]) ) return "OrT";
75 if ( uTruth ==~(uTruths6[0] | uTruths6[1]) ) return "NorT";
76 if ( uTruth == (uTruths6[0] ^ uTruths6[1]) ) return "XorT";
77 if ( uTruth ==~(uTruths6[0] ^ uTruths6[1]) ) return "XnorT";
78 assert( 0 );
79 return NULL;
80 }
81
82
83 /**Function*************************************************************
84
85 Synopsis [Create Ptr from Abc_Ntk_t.]
86
87 Description []
88
89 SideEffects []
90
91 SeeAlso []
92
93 ***********************************************************************/
Ptr_AbcObjName(Abc_Obj_t * pObj)94 char * Ptr_AbcObjName( Abc_Obj_t * pObj )
95 {
96 if ( Abc_ObjIsNet(pObj) || Abc_ObjIsBox(pObj) )
97 return Abc_ObjName(pObj);
98 if ( Abc_ObjIsCi(pObj) || Abc_ObjIsNode(pObj) )
99 return Ptr_AbcObjName(Abc_ObjFanout0(pObj));
100 if ( Abc_ObjIsCo(pObj) )
101 return Ptr_AbcObjName(Abc_ObjFanin0(pObj));
102 assert( 0 );
103 return NULL;
104 }
Ptr_CheckArray(Vec_Ptr_t * vArray)105 static int Ptr_CheckArray( Vec_Ptr_t * vArray )
106 {
107 assert( Vec_PtrSize(vArray) == Vec_PtrCap(vArray) );
108 return 1;
109 }
Ptr_AbcDeriveNode(Abc_Obj_t * pObj)110 Vec_Ptr_t * Ptr_AbcDeriveNode( Abc_Obj_t * pObj )
111 {
112 Abc_Obj_t * pFanin; int i;
113 Vec_Ptr_t * vNode = Vec_PtrAllocExact( 2 + 2 * (1 + Abc_ObjFaninNum(pObj)) );
114 assert( Abc_ObjIsNode(pObj) );
115 if ( Abc_NtkHasAig(pObj->pNtk) )
116 Vec_PtrPush( vNode, Ptr_HopToType(pObj) );
117 else if ( Abc_NtkHasSop(pObj->pNtk) )
118 Vec_PtrPush( vNode, Ptr_SopToTypeName((char *)pObj->pData) );
119 else assert( 0 );
120 Vec_PtrPush( vNode, Ptr_AbcObjName(pObj) );
121 assert( Abc_ObjFaninNum(pObj) <= 2 );
122 Abc_ObjForEachFanin( pObj, pFanin, i )
123 {
124 Vec_PtrPush( vNode, (void*)(i ? "r" : "l") );
125 Vec_PtrPush( vNode, Ptr_AbcObjName(pFanin) );
126 }
127 Vec_PtrPush( vNode, (void*)("o") );
128 Vec_PtrPush( vNode, Ptr_AbcObjName(pObj) );
129 assert( Ptr_CheckArray(vNode) );
130 return vNode;
131 }
Ptr_AbcDeriveBox(Abc_Obj_t * pObj)132 Vec_Ptr_t * Ptr_AbcDeriveBox( Abc_Obj_t * pObj )
133 {
134 Abc_Obj_t * pNext; int i;
135 Abc_Ntk_t * pNtk = Abc_ObjModel(pObj);
136 Vec_Ptr_t * vBox = Vec_PtrAllocExact( 2 + 2 * Abc_ObjFaninNum(pObj) + 2 * Abc_ObjFanoutNum(pObj) );
137 assert( Abc_ObjIsBox(pObj) );
138 Vec_PtrPush( vBox, Abc_NtkName(pNtk) );
139 Vec_PtrPush( vBox, Ptr_AbcObjName(pObj) );
140 Abc_ObjForEachFanin( pObj, pNext, i )
141 {
142 Vec_PtrPush( vBox, Ptr_AbcObjName(Abc_NtkPi(pNtk, i)) );
143 Vec_PtrPush( vBox, Ptr_AbcObjName(pNext) );
144 }
145 Abc_ObjForEachFanout( pObj, pNext, i )
146 {
147 Vec_PtrPush( vBox, Ptr_AbcObjName(Abc_NtkPo(pNtk, i)) );
148 Vec_PtrPush( vBox, Ptr_AbcObjName(pNext) );
149 }
150 assert( Ptr_CheckArray(vBox) );
151 return vBox;
152 }
Ptr_AbcDeriveBoxes(Abc_Ntk_t * pNtk)153 Vec_Ptr_t * Ptr_AbcDeriveBoxes( Abc_Ntk_t * pNtk )
154 {
155 Abc_Obj_t * pObj; int i;
156 Vec_Ptr_t * vBoxes = Vec_PtrAllocExact( Abc_NtkBoxNum(pNtk) + Abc_NtkNodeNum(pNtk) );
157 Abc_NtkForEachBox( pNtk, pObj, i )
158 Vec_PtrPush( vBoxes, Ptr_AbcDeriveBox(pObj) );
159 Abc_NtkForEachNode( pNtk, pObj, i )
160 Vec_PtrPush( vBoxes, Ptr_AbcDeriveNode(pObj) );
161 assert( Ptr_CheckArray(vBoxes) );
162 return vBoxes;
163 }
164
Ptr_AbcDeriveInputs(Abc_Ntk_t * pNtk)165 Vec_Ptr_t * Ptr_AbcDeriveInputs( Abc_Ntk_t * pNtk )
166 {
167 Abc_Obj_t * pObj; int i;
168 Vec_Ptr_t * vSigs = Vec_PtrAllocExact( Abc_NtkPiNum(pNtk) );
169 Abc_NtkForEachPi( pNtk, pObj, i )
170 Vec_PtrPush( vSigs, Ptr_AbcObjName(pObj) );
171 assert( Ptr_CheckArray(vSigs) );
172 return vSigs;
173 }
Ptr_AbcDeriveOutputs(Abc_Ntk_t * pNtk)174 Vec_Ptr_t * Ptr_AbcDeriveOutputs( Abc_Ntk_t * pNtk )
175 {
176 Abc_Obj_t * pObj; int i;
177 Vec_Ptr_t * vSigs = Vec_PtrAllocExact( Abc_NtkPoNum(pNtk) );
178 Abc_NtkForEachPo( pNtk, pObj, i )
179 Vec_PtrPush( vSigs, Ptr_AbcObjName(pObj) );
180 assert( Ptr_CheckArray(vSigs) );
181 return vSigs;
182 }
Ptr_AbcDeriveNtk(Abc_Ntk_t * pNtk)183 Vec_Ptr_t * Ptr_AbcDeriveNtk( Abc_Ntk_t * pNtk )
184 {
185 Vec_Ptr_t * vNtk = Vec_PtrAllocExact( 5 );
186 Vec_PtrPush( vNtk, Abc_NtkName(pNtk) );
187 Vec_PtrPush( vNtk, Ptr_AbcDeriveInputs(pNtk) );
188 Vec_PtrPush( vNtk, Ptr_AbcDeriveOutputs(pNtk) );
189 Vec_PtrPush( vNtk, Vec_PtrAllocExact(0) );
190 Vec_PtrPush( vNtk, Ptr_AbcDeriveBoxes(pNtk) );
191 assert( Ptr_CheckArray(vNtk) );
192 return vNtk;
193 }
Ptr_AbcDeriveDes(Abc_Ntk_t * pNtk)194 Vec_Ptr_t * Ptr_AbcDeriveDes( Abc_Ntk_t * pNtk )
195 {
196 Vec_Ptr_t * vDes;
197 Abc_Ntk_t * pTemp; int i;
198 vDes = Vec_PtrAllocExact( 1 + Vec_PtrSize(pNtk->pDesign->vModules) );
199 Vec_PtrPush( vDes, pNtk->pDesign->pName );
200 Vec_PtrForEachEntry( Abc_Ntk_t *, pNtk->pDesign->vModules, pTemp, i )
201 Vec_PtrPush( vDes, Ptr_AbcDeriveNtk(pTemp) );
202 assert( Ptr_CheckArray(vDes) );
203 return vDes;
204 }
205
206 /**Function*************************************************************
207
208 Synopsis []
209
210 Description []
211
212 SideEffects []
213
214 SeeAlso []
215
216 ***********************************************************************/
Ptr_ManExperiment(Abc_Ntk_t * pNtk)217 void Ptr_ManExperiment( Abc_Ntk_t * pNtk )
218 {
219 abctime clk = Abc_Clock();
220 char * pFileName = Extra_FileNameGenericAppend(pNtk->pDesign->pName, "_out.blif");
221 Vec_Ptr_t * vDes = Ptr_AbcDeriveDes( pNtk );
222 printf( "Converting to Ptr: Memory = %6.3f MB ", 1.0*Bac_PtrMemory(vDes)/(1<<20) );
223 Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
224 Bac_PtrDumpBlif( pFileName, vDes );
225 printf( "Finished writing output file \"%s\". ", pFileName );
226 Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
227 Bac_PtrFree( vDes );
228 }
229
230 /**Function*************************************************************
231
232 Synopsis [Create Bac_Man_t from tech-ind Ptr.]
233
234 Description []
235
236 SideEffects []
237
238 SeeAlso []
239
240 ***********************************************************************/
Ptr_NameToType(char * pSop)241 static inline int Ptr_NameToType( char * pSop )
242 {
243 if ( !strcmp(pSop, "Const0T") ) return BAC_BOX_CF;
244 if ( !strcmp(pSop, "Const1T") ) return BAC_BOX_CT;
245 if ( !strcmp(pSop, "BufT") ) return BAC_BOX_BUF;
246 if ( !strcmp(pSop, "InvT") ) return BAC_BOX_INV;
247 if ( !strcmp(pSop, "AndT") ) return BAC_BOX_AND;
248 if ( !strcmp(pSop, "NandT") ) return BAC_BOX_NAND;
249 if ( !strcmp(pSop, "OrT") ) return BAC_BOX_OR;
250 if ( !strcmp(pSop, "NorT") ) return BAC_BOX_NOR;
251 if ( !strcmp(pSop, "XorT") ) return BAC_BOX_XOR;
252 if ( !strcmp(pSop, "XnorT") ) return BAC_BOX_XNOR;
253 return BAC_OBJ_BOX;
254 }
Ptr_ManCountNtk(Vec_Ptr_t * vNtk)255 int Ptr_ManCountNtk( Vec_Ptr_t * vNtk )
256 {
257 Vec_Ptr_t * vInputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1);
258 Vec_Ptr_t * vOutputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2);
259 Vec_Ptr_t * vNodes = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 3);
260 Vec_Ptr_t * vBoxes = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4);
261 Vec_Ptr_t * vBox; int i, Counter = 0;
262 assert( Vec_PtrSize(vNodes) == 0 );
263 Counter += Vec_PtrSize(vInputs);
264 Counter += Vec_PtrSize(vOutputs);
265 Vec_PtrForEachEntry( Vec_Ptr_t *, vBoxes, vBox, i )
266 Counter += Vec_PtrSize(vBox)/2;
267 return Counter;
268 }
Bac_BoxCountOutputs(Bac_Ntk_t * pNtk,char * pBoxNtk)269 int Bac_BoxCountOutputs( Bac_Ntk_t * pNtk, char * pBoxNtk )
270 {
271 int ModuleId = Bac_ManNtkFindId( pNtk->pDesign, pBoxNtk );
272 if ( ModuleId == 0 )
273 return 1;
274 return Bac_NtkPoNumAlloc( Bac_ManNtk(pNtk->pDesign, ModuleId) );
275 }
Bac_NtkDeriveFromPtr(Bac_Ntk_t * pNtk,Vec_Ptr_t * vNtk,Vec_Int_t * vMap,Vec_Int_t * vBox2Id)276 int Bac_NtkDeriveFromPtr( Bac_Ntk_t * pNtk, Vec_Ptr_t * vNtk, Vec_Int_t * vMap, Vec_Int_t * vBox2Id )
277 {
278 char * pName, * pModuleName = (char *)Vec_PtrEntry(vNtk, 0);
279 Vec_Ptr_t * vInputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1);
280 Vec_Ptr_t * vOutputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2);
281 Vec_Ptr_t * vBoxes = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 4), * vBox;
282 int i, k, iObj, iTerm, NameId;
283 // start network with the given name
284 NameId = Abc_NamStrFindOrAdd( pNtk->pDesign->pStrs, pModuleName, NULL );
285 assert( Bac_NtkNameId(pNtk) == NameId );
286 // map driven NameIds into their ObjIds for PIs
287 Vec_PtrForEachEntry( char *, vInputs, pName, i )
288 {
289 NameId = Abc_NamStrFindOrAdd( pNtk->pDesign->pStrs, pName, NULL );
290 if ( Vec_IntGetEntryFull(vMap, NameId) != -1 )
291 { printf( "PI with name \"%s\" is not unique module \"%s\".\n", pName, pModuleName ); return 0; }
292 iObj = Bac_ObjAlloc( pNtk, BAC_OBJ_PI, -1 );
293 Bac_ObjSetName( pNtk, iObj, Abc_Var2Lit2(NameId, BAC_NAME_BIN) );
294 Vec_IntSetEntryFull( vMap, NameId, iObj );
295 Bac_NtkAddInfo( pNtk, Abc_Var2Lit2(NameId, 1), -1, -1 );
296 }
297 // map driven NameIds into their ObjIds for BOs
298 Vec_IntClear( vBox2Id );
299 Vec_PtrForEachEntry( Vec_Ptr_t *, vBoxes, vBox, i )
300 {
301 char * pBoxNtk = (char *)Vec_PtrEntry(vBox, 0);
302 char * pBoxName = (char *)Vec_PtrEntry(vBox, 1);
303 int nOutputs = Bac_BoxCountOutputs( pNtk, pBoxNtk );
304 int nInputs = Vec_PtrSize(vBox)/2 - nOutputs - 1;
305 int NtkId = Bac_ManNtkFindId( pNtk->pDesign, pBoxNtk );
306 assert( Vec_PtrSize(vBox) % 2 == 0 );
307 assert( nOutputs > 0 && 2*(nOutputs + 1) <= Vec_PtrSize(vBox) );
308 iObj = Bac_BoxAlloc( pNtk, (Bac_ObjType_t)Ptr_NameToType(pBoxNtk), nInputs, nOutputs, NtkId );
309 if ( NtkId > 0 )
310 Bac_NtkSetHost( Bac_ManNtk(pNtk->pDesign, NtkId), Bac_NtkId(pNtk), iObj );
311 Bac_ObjSetName( pNtk, iObj, Abc_Var2Lit2(Abc_NamStrFindOrAdd(pNtk->pDesign->pStrs, pBoxName, NULL), BAC_NAME_BIN) );
312 Bac_BoxForEachBo( pNtk, iObj, iTerm, k )
313 {
314 pName = (char *)Vec_PtrEntry( vBox, Vec_PtrSize(vBox) - 2*(nOutputs - k) + 1 );
315 NameId = Abc_NamStrFindOrAdd( pNtk->pDesign->pStrs, pName, NULL );
316 if ( Vec_IntGetEntryFull(vMap, NameId) != -1 )
317 { printf( "Signal \"%s\" has multiple drivers in module \"%s\".\n", pName, pModuleName ); return 0; }
318 Bac_ObjSetName( pNtk, iTerm, Abc_Var2Lit2(NameId, BAC_NAME_BIN) );
319 Vec_IntSetEntryFull( vMap, NameId, iTerm );
320 }
321 Vec_IntPush( vBox2Id, iObj );
322 }
323 assert( Vec_IntSize(vBox2Id) == Vec_PtrSize(vBoxes) );
324 // connect BIs
325 Vec_PtrForEachEntry( Vec_Ptr_t *, vBoxes, vBox, i )
326 {
327 iObj = Vec_IntEntry( vBox2Id, i );
328 Bac_BoxForEachBi( pNtk, iObj, iTerm, k )
329 {
330 pName = (char *)Vec_PtrEntry( vBox, 2*(k + 1) + 1 );
331 NameId = Abc_NamStrFindOrAdd( pNtk->pDesign->pStrs, pName, NULL );
332 if ( Vec_IntGetEntryFull(vMap, NameId) == -1 )
333 printf( "Signal \"%s\" in not driven in module \"%s\".\n", pName, pModuleName );
334 Bac_ObjSetFanin( pNtk, iTerm, Vec_IntGetEntryFull(vMap, NameId) );
335 }
336 }
337 // connect POs
338 Vec_PtrForEachEntry( char *, vOutputs, pName, i )
339 {
340 NameId = Abc_NamStrFindOrAdd( pNtk->pDesign->pStrs, pName, NULL );
341 if ( Vec_IntGetEntryFull(vMap, NameId) == -1 )
342 printf( "PO with name \"%s\" in not driven in module \"%s\".\n", pName, pModuleName );
343 iObj = Bac_ObjAlloc( pNtk, BAC_OBJ_PO, Vec_IntGetEntryFull(vMap, NameId) );
344 Bac_NtkAddInfo( pNtk, Abc_Var2Lit2(NameId, 2), -1, -1 );
345 }
346 // update map
347 Bac_NtkForEachCi( pNtk, iObj )
348 Vec_IntSetEntryFull( vMap, Bac_ObjNameId(pNtk, iObj), -1 );
349 // double check
350 Vec_IntForEachEntry( vMap, iObj, i )
351 assert( iObj == -1 );
352 assert( Bac_NtkObjNum(pNtk) == Vec_StrCap(&pNtk->vType) );
353 return 1;
354 }
Bac_PtrTransformToCba(Vec_Ptr_t * vDes)355 Bac_Man_t * Bac_PtrTransformToCba( Vec_Ptr_t * vDes )
356 {
357 char * pName = (char *)Vec_PtrEntry(vDes, 0);
358 Bac_Man_t * pNew = Bac_ManAlloc( pName, Vec_PtrSize(vDes) - 1 );
359 Vec_Int_t * vMap = Vec_IntStartFull( 1000 );
360 Vec_Int_t * vBox2Id = Vec_IntAlloc( 1000 );
361 // create interfaces
362 Bac_Ntk_t * pNtk; int i;
363 Bac_ManForEachNtk( pNew, pNtk, i )
364 {
365 Vec_Ptr_t * vNtk = (Vec_Ptr_t *)Vec_PtrEntry(vDes, i);
366 Vec_Ptr_t * vInputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 1);
367 Vec_Ptr_t * vOutputs = (Vec_Ptr_t *)Vec_PtrEntry(vNtk, 2);
368 int NameId = Abc_NamStrFindOrAdd( pNew->pStrs, (char *)Vec_PtrEntry(vNtk, 0), NULL );
369 Bac_NtkAlloc( pNtk, NameId, Vec_PtrSize(vInputs), Vec_PtrSize(vOutputs), Ptr_ManCountNtk(vNtk) );
370 Bac_NtkStartNames( pNtk );
371 }
372 // parse the networks
373 Bac_ManForEachNtk( pNew, pNtk, i )
374 {
375 Vec_Ptr_t * vNtk = (Vec_Ptr_t *)Vec_PtrEntry(vDes, i);
376 if ( !Bac_NtkDeriveFromPtr( pNtk, vNtk, vMap, vBox2Id ) )
377 break;
378 }
379 if ( i <= Bac_ManNtkNum(pNew) )
380 Bac_ManFree(pNew), pNew = NULL;
381 Vec_IntFree( vBox2Id );
382 Vec_IntFree( vMap );
383 return pNew;
384 }
385
386
387 /**Function*************************************************************
388
389 Synopsis [Create Ptr from mapped Bac_Man_t.]
390
391 Description []
392
393 SideEffects []
394
395 SeeAlso []
396
397 ***********************************************************************/
Bac_NtkTransformToPtrBox(Bac_Ntk_t * p,int iBox)398 Vec_Ptr_t * Bac_NtkTransformToPtrBox( Bac_Ntk_t * p, int iBox )
399 {
400 int i, iTerm, fUser = Bac_ObjIsBoxUser( p, iBox );
401 Bac_Ntk_t * pBoxNtk = Bac_BoxNtk( p, iBox );
402 Mio_Library_t * pLib = (Mio_Library_t *)p->pDesign->pMioLib;
403 Mio_Gate_t * pGate = pLib ? Mio_LibraryReadGateByName( pLib, Bac_BoxNtkName(p, iBox), NULL ) : NULL;
404 Vec_Ptr_t * vBox = Vec_PtrAllocExact( 2*Bac_BoxSize(p, iBox) );
405 Vec_PtrPush( vBox, Bac_BoxNtkName(p, iBox) );
406 Vec_PtrPush( vBox, Bac_ObjNameStr(p, iBox) );
407 Bac_BoxForEachBi( p, iBox, iTerm, i )
408 {
409 Vec_PtrPush( vBox, fUser ? Bac_ObjNameStr(pBoxNtk, Bac_NtkPi(pBoxNtk, i)) : Mio_GateReadPinName(pGate, i) );
410 Vec_PtrPush( vBox, Bac_ObjNameStr(p, iTerm) );
411 }
412 Bac_BoxForEachBo( p, iBox, iTerm, i )
413 {
414 Vec_PtrPush( vBox, fUser ? Bac_ObjNameStr(pBoxNtk, Bac_NtkPo(pBoxNtk, i)) : Mio_GateReadOutName(pGate) );
415 Vec_PtrPush( vBox, Bac_ObjNameStr(p, iTerm) );
416 }
417 assert( Ptr_CheckArray(vBox) );
418 return vBox;
419 }
Bac_NtkTransformToPtrBoxes(Bac_Ntk_t * p)420 Vec_Ptr_t * Bac_NtkTransformToPtrBoxes( Bac_Ntk_t * p )
421 {
422 int iBox;
423 Vec_Ptr_t * vBoxes = Vec_PtrAllocExact( Bac_NtkBoxNum(p) );
424 Bac_NtkForEachBox( p, iBox )
425 Vec_PtrPush( vBoxes, Bac_NtkTransformToPtrBox(p, iBox) );
426 assert( Ptr_CheckArray(vBoxes) );
427 return vBoxes;
428 }
429
Bac_NtkTransformToPtrInputs(Bac_Ntk_t * p)430 Vec_Ptr_t * Bac_NtkTransformToPtrInputs( Bac_Ntk_t * p )
431 {
432 int i, iTerm;
433 Vec_Ptr_t * vSigs = Vec_PtrAllocExact( Bac_NtkPiNum(p) );
434 Bac_NtkForEachPi( p, iTerm, i )
435 Vec_PtrPush( vSigs, Bac_ObjNameStr(p, iTerm) );
436 assert( Ptr_CheckArray(vSigs) );
437 return vSigs;
438 }
Bac_NtkTransformToPtrOutputs(Bac_Ntk_t * p)439 Vec_Ptr_t * Bac_NtkTransformToPtrOutputs( Bac_Ntk_t * p )
440 {
441 int i, iTerm;
442 Vec_Ptr_t * vSigs = Vec_PtrAllocExact( Bac_NtkPoNum(p) );
443 Bac_NtkForEachPo( p, iTerm, i )
444 Vec_PtrPush( vSigs, Bac_ObjNameStr(p, iTerm) );
445 assert( Ptr_CheckArray(vSigs) );
446 return vSigs;
447 }
Bac_NtkTransformToPtr(Bac_Ntk_t * p)448 Vec_Ptr_t * Bac_NtkTransformToPtr( Bac_Ntk_t * p )
449 {
450 Vec_Ptr_t * vNtk = Vec_PtrAllocExact(5);
451 Vec_PtrPush( vNtk, Bac_NtkName(p) );
452 Vec_PtrPush( vNtk, Bac_NtkTransformToPtrInputs(p) );
453 Vec_PtrPush( vNtk, Bac_NtkTransformToPtrOutputs(p) );
454 Vec_PtrPush( vNtk, Vec_PtrAllocExact(0) );
455 Vec_PtrPush( vNtk, Bac_NtkTransformToPtrBoxes(p) );
456 assert( Ptr_CheckArray(vNtk) );
457 return vNtk;
458 }
Bac_PtrDeriveFromCba(Bac_Man_t * p)459 Vec_Ptr_t * Bac_PtrDeriveFromCba( Bac_Man_t * p )
460 {
461 Vec_Ptr_t * vDes;
462 Bac_Ntk_t * pTemp; int i;
463 if ( p == NULL )
464 return NULL;
465 if ( p->pMioLib == NULL )
466 {
467 printf( "Cannot transform CBA network into Ptr because it is not mapped.\n" );
468 return NULL;
469 }
470 Bac_ManAssignInternWordNames( p );
471 vDes = Vec_PtrAllocExact( 1 + Bac_ManNtkNum(p) );
472 Vec_PtrPush( vDes, p->pName );
473 Bac_ManForEachNtk( p, pTemp, i )
474 Vec_PtrPush( vDes, Bac_NtkTransformToPtr(pTemp) );
475 assert( Ptr_CheckArray(vDes) );
476 return vDes;
477 }
478
479
480 ////////////////////////////////////////////////////////////////////////
481 /// END OF FILE ///
482 ////////////////////////////////////////////////////////////////////////
483
484
485 ABC_NAMESPACE_IMPL_END
486
487