1 /**CFile****************************************************************
2
3 FileName [ioUtil.c]
4
5 SystemName [ABC: Logic synthesis and verification system.]
6
7 PackageName [Command processing package.]
8
9 Synopsis [Procedures to write the network in BENCH format.]
10
11 Author [Alan Mishchenko]
12
13 Affiliation [UC Berkeley]
14
15 Date [Ver. 1.0. Started - June 20, 2005.]
16
17 Revision [$Id: ioUtil.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
18
19 ***********************************************************************/
20
21 #include "ioAbc.h"
22 #include "base/main/main.h"
23
24 ABC_NAMESPACE_IMPL_START
25
26
27 ////////////////////////////////////////////////////////////////////////
28 /// DECLARATIONS ///
29 ////////////////////////////////////////////////////////////////////////
30
31 ////////////////////////////////////////////////////////////////////////
32 /// FUNCTION DEFINITIONS ///
33 ////////////////////////////////////////////////////////////////////////
34
35 /**Function*************************************************************
36
37 Synopsis [Returns the file type.]
38
39 Description []
40
41 SideEffects []
42
43 SeeAlso []
44
45 ***********************************************************************/
Io_ReadFileType(char * pFileName)46 Io_FileType_t Io_ReadFileType( char * pFileName )
47 {
48 char * pExt;
49 if ( pFileName == NULL )
50 return IO_FILE_NONE;
51 pExt = Extra_FileNameExtension( pFileName );
52 if ( pExt == NULL )
53 return IO_FILE_NONE;
54 if ( !strcmp( pExt, "aig" ) )
55 return IO_FILE_AIGER;
56 if ( !strcmp( pExt, "baf" ) )
57 return IO_FILE_BAF;
58 if ( !strcmp( pExt, "bblif" ) )
59 return IO_FILE_BBLIF;
60 if ( !strcmp( pExt, "blif" ) )
61 return IO_FILE_BLIF;
62 if ( !strcmp( pExt, "bench" ) )
63 return IO_FILE_BENCH;
64 if ( !strcmp( pExt, "cnf" ) )
65 return IO_FILE_CNF;
66 if ( !strcmp( pExt, "dot" ) )
67 return IO_FILE_DOT;
68 if ( !strcmp( pExt, "edif" ) )
69 return IO_FILE_EDIF;
70 if ( !strcmp( pExt, "eqn" ) )
71 return IO_FILE_EQN;
72 if ( !strcmp( pExt, "gml" ) )
73 return IO_FILE_GML;
74 if ( !strcmp( pExt, "list" ) )
75 return IO_FILE_LIST;
76 if ( !strcmp( pExt, "mv" ) )
77 return IO_FILE_BLIFMV;
78 if ( !strcmp( pExt, "pla" ) )
79 return IO_FILE_PLA;
80 if ( !strcmp( pExt, "smv" ) )
81 return IO_FILE_SMV;
82 if ( !strcmp( pExt, "v" ) )
83 return IO_FILE_VERILOG;
84 return IO_FILE_UNKNOWN;
85 }
86
87 /**Function*************************************************************
88
89 Synopsis [Read the network from a file.]
90
91 Description []
92
93 SideEffects []
94
95 SeeAlso []
96
97 ***********************************************************************/
Io_ReadNetlist(char * pFileName,Io_FileType_t FileType,int fCheck)98 Abc_Ntk_t * Io_ReadNetlist( char * pFileName, Io_FileType_t FileType, int fCheck )
99 {
100 FILE * pFile;
101 Abc_Ntk_t * pNtk;
102 if ( FileType == IO_FILE_NONE || FileType == IO_FILE_UNKNOWN )
103 {
104 fprintf( stdout, "Generic file reader requires a known file extension to open \"%s\".\n", pFileName );
105 return NULL;
106 }
107 // check if the file exists
108 pFile = fopen( pFileName, "r" );
109 if ( pFile == NULL )
110 {
111 fprintf( stdout, "Cannot open input file \"%s\". ", pFileName );
112 if ( (pFileName = Extra_FileGetSimilarName( pFileName, ".blif", ".bench", ".pla", ".baf", ".aig" )) )
113 fprintf( stdout, "Did you mean \"%s\"?", pFileName );
114 fprintf( stdout, "\n" );
115 return NULL;
116 }
117 fclose( pFile );
118 // read the AIG
119 if ( FileType == IO_FILE_AIGER || FileType == IO_FILE_BAF || FileType == IO_FILE_BBLIF )
120 {
121 if ( FileType == IO_FILE_AIGER )
122 pNtk = Io_ReadAiger( pFileName, fCheck );
123 else if ( FileType == IO_FILE_BAF )
124 pNtk = Io_ReadBaf( pFileName, fCheck );
125 else // if ( FileType == IO_FILE_BBLIF )
126 pNtk = Io_ReadBblif( pFileName, fCheck );
127 if ( pNtk == NULL )
128 {
129 fprintf( stdout, "Reading AIG from file has failed.\n" );
130 return NULL;
131 }
132 return pNtk;
133 }
134 // read the new netlist
135 if ( FileType == IO_FILE_BLIF )
136 // pNtk = Io_ReadBlif( pFileName, fCheck );
137 pNtk = Io_ReadBlifMv( pFileName, 0, fCheck );
138 else if ( Io_ReadFileType(pFileName) == IO_FILE_BLIFMV )
139 pNtk = Io_ReadBlifMv( pFileName, 1, fCheck );
140 else if ( FileType == IO_FILE_BENCH )
141 pNtk = Io_ReadBench( pFileName, fCheck );
142 else if ( FileType == IO_FILE_EDIF )
143 pNtk = Io_ReadEdif( pFileName, fCheck );
144 else if ( FileType == IO_FILE_EQN )
145 pNtk = Io_ReadEqn( pFileName, fCheck );
146 else if ( FileType == IO_FILE_PLA )
147 pNtk = Io_ReadPla( pFileName, 0, 0, 0, 0, fCheck );
148 else if ( FileType == IO_FILE_VERILOG )
149 pNtk = Io_ReadVerilog( pFileName, fCheck );
150 else
151 {
152 fprintf( stderr, "Unknown file format.\n" );
153 return NULL;
154 }
155 if ( pNtk == NULL )
156 {
157 fprintf( stdout, "Reading network from file has failed.\n" );
158 return NULL;
159 }
160 if ( fCheck && (Abc_NtkBlackboxNum(pNtk) || Abc_NtkWhiteboxNum(pNtk)) )
161 {
162 int i, fCycle = 0;
163 Abc_Ntk_t * pModel;
164 // fprintf( stdout, "Warning: The network contains hierarchy.\n" );
165 Vec_PtrForEachEntry( Abc_Ntk_t *, pNtk->pDesign->vModules, pModel, i )
166 if ( !Abc_NtkIsAcyclicWithBoxes( pModel ) )
167 fCycle = 1;
168 if ( fCycle )
169 {
170 Abc_NtkDelete( pNtk );
171 return NULL;
172 }
173 }
174 return pNtk;
175 }
176
177 /**Function*************************************************************
178
179 Synopsis []
180
181 Description []
182
183 SideEffects []
184
185 SeeAlso []
186
187 ***********************************************************************/
temporaryLtlStore(Abc_Ntk_t * pNtk)188 Vec_Ptr_t *temporaryLtlStore( Abc_Ntk_t *pNtk )
189 {
190 Vec_Ptr_t *tempStore;
191 char *pFormula;
192 int i;
193
194 if( pNtk && Vec_PtrSize( pNtk->vLtlProperties ) > 0 )
195 {
196 tempStore = Vec_PtrAlloc( Vec_PtrSize( pNtk->vLtlProperties ) );
197 Vec_PtrForEachEntry( char *, pNtk->vLtlProperties, pFormula, i )
198 Vec_PtrPush( tempStore, pFormula );
199 assert( Vec_PtrSize( tempStore ) == Vec_PtrSize( pNtk->vLtlProperties ) );
200 return tempStore;
201 }
202 else
203 return NULL;
204 }
205
206 /**Function*************************************************************
207
208 Synopsis []
209
210 Description []
211
212 SideEffects []
213
214 SeeAlso []
215
216 ***********************************************************************/
updateLtlStoreOfNtk(Abc_Ntk_t * pNtk,Vec_Ptr_t * tempLtlStore)217 void updateLtlStoreOfNtk( Abc_Ntk_t *pNtk, Vec_Ptr_t *tempLtlStore )
218 {
219 int i;
220 char *pFormula;
221
222 assert( tempLtlStore != NULL );
223 Vec_PtrForEachEntry( char *, tempLtlStore, pFormula, i )
224 Vec_PtrPush( pNtk->vLtlProperties, pFormula );
225 }
226
227 /**Function*************************************************************
228
229 Synopsis [Read the network from a file.]
230
231 Description []
232
233 SideEffects []
234
235 SeeAlso []
236
237 ***********************************************************************/
Io_Read(char * pFileName,Io_FileType_t FileType,int fCheck,int fBarBufs)238 Abc_Ntk_t * Io_Read( char * pFileName, Io_FileType_t FileType, int fCheck, int fBarBufs )
239 {
240 Abc_Ntk_t * pNtk, * pTemp;
241 Vec_Ptr_t * vLtl;
242 // get the netlist
243 pNtk = Io_ReadNetlist( pFileName, FileType, fCheck );
244 if ( pNtk == NULL )
245 return NULL;
246 vLtl = temporaryLtlStore( pNtk );
247 if ( !Abc_NtkIsNetlist(pNtk) )
248 return pNtk;
249 // derive barbufs
250 if ( fBarBufs )
251 {
252 pNtk = Abc_NtkToBarBufs( pTemp = pNtk );
253 Abc_NtkDelete( pTemp );
254 assert( Abc_NtkIsLogic(pNtk) );
255 return pNtk;
256 }
257 // flatten logic hierarchy
258 assert( Abc_NtkIsNetlist(pNtk) );
259 if ( Abc_NtkWhiteboxNum(pNtk) > 0 )
260 {
261 pNtk = Abc_NtkFlattenLogicHierarchy( pTemp = pNtk );
262 Abc_NtkDelete( pTemp );
263 if ( pNtk == NULL )
264 {
265 fprintf( stdout, "Flattening logic hierarchy has failed.\n" );
266 return NULL;
267 }
268 }
269 // convert blackboxes
270 if ( Abc_NtkBlackboxNum(pNtk) > 0 )
271 {
272 printf( "Hierarchy reader converted %d instances of blackboxes.\n", Abc_NtkBlackboxNum(pNtk) );
273 pNtk = Abc_NtkConvertBlackboxes( pTemp = pNtk );
274 Abc_NtkDelete( pTemp );
275 if ( pNtk == NULL )
276 {
277 fprintf( stdout, "Converting blackboxes has failed.\n" );
278 return NULL;
279 }
280 }
281 // consider the case of BLIF-MV
282 if ( Io_ReadFileType(pFileName) == IO_FILE_BLIFMV )
283 {
284 pNtk = Abc_NtkStrashBlifMv( pTemp = pNtk );
285 Abc_NtkDelete( pTemp );
286 if ( pNtk == NULL )
287 {
288 fprintf( stdout, "Converting BLIF-MV to AIG has failed.\n" );
289 return NULL;
290 }
291 return pNtk;
292 }
293 // convert the netlist into the logic network
294 pNtk = Abc_NtkToLogic( pTemp = pNtk );
295 if( vLtl )
296 updateLtlStoreOfNtk( pNtk, vLtl );
297 Abc_NtkDelete( pTemp );
298 if ( pNtk == NULL )
299 {
300 fprintf( stdout, "Converting netlist to logic network after reading has failed.\n" );
301 return NULL;
302 }
303 return pNtk;
304 }
305
306 /**Function*************************************************************
307
308 Synopsis [Write the network into file.]
309
310 Description []
311
312 SideEffects []
313
314 SeeAlso []
315
316 ***********************************************************************/
Io_Write(Abc_Ntk_t * pNtk,char * pFileName,Io_FileType_t FileType)317 void Io_Write( Abc_Ntk_t * pNtk, char * pFileName, Io_FileType_t FileType )
318 {
319 Abc_Ntk_t * pNtkTemp, * pNtkCopy;
320 // check if the current network is available
321 if ( pNtk == NULL )
322 {
323 fprintf( stdout, "Empty network.\n" );
324 return;
325 }
326 // check if the file extension if given
327 if ( FileType == IO_FILE_NONE || FileType == IO_FILE_UNKNOWN )
328 {
329 fprintf( stdout, "The generic file writer requires a known file extension.\n" );
330 return;
331 }
332 // write the AIG formats
333 if ( FileType == IO_FILE_AIGER || FileType == IO_FILE_BAF )
334 {
335 if ( !Abc_NtkIsStrash(pNtk) )
336 {
337 fprintf( stdout, "Writing this format is only possible for structurally hashed AIGs.\n" );
338 return;
339 }
340 if ( FileType == IO_FILE_AIGER )
341 Io_WriteAiger( pNtk, pFileName, 1, 0, 0 );
342 else //if ( FileType == IO_FILE_BAF )
343 Io_WriteBaf( pNtk, pFileName );
344 return;
345 }
346 // write non-netlist types
347 if ( FileType == IO_FILE_CNF )
348 {
349 Io_WriteCnf( pNtk, pFileName, 0 );
350 return;
351 }
352 if ( FileType == IO_FILE_DOT )
353 {
354 Io_WriteDot( pNtk, pFileName );
355 return;
356 }
357 if ( FileType == IO_FILE_GML )
358 {
359 Io_WriteGml( pNtk, pFileName );
360 return;
361 }
362 if ( FileType == IO_FILE_BBLIF )
363 {
364 if ( !Abc_NtkIsLogic(pNtk) )
365 {
366 fprintf( stdout, "Writing Binary BLIF is only possible for logic networks.\n" );
367 return;
368 }
369 if ( !Abc_NtkHasSop(pNtk) )
370 Abc_NtkToSop( pNtk, -1, ABC_INFINITY );
371 Io_WriteBblif( pNtk, pFileName );
372 return;
373 }
374 /*
375 if ( FileType == IO_FILE_BLIFMV )
376 {
377 Io_WriteBlifMv( pNtk, pFileName );
378 return;
379 }
380 */
381 // convert logic network into netlist
382 if ( FileType == IO_FILE_PLA )
383 {
384 if ( Abc_NtkLevel(pNtk) > 1 )
385 {
386 fprintf( stdout, "PLA writing is available for collapsed networks.\n" );
387 return;
388 }
389 if ( Abc_NtkIsComb(pNtk) )
390 pNtkTemp = Abc_NtkToNetlist( pNtk );
391 else
392 {
393 fprintf( stdout, "Latches are writen into the PLA file at PI/PO pairs.\n" );
394 pNtkCopy = Abc_NtkDup( pNtk );
395 Abc_NtkMakeComb( pNtkCopy, 0 );
396 pNtkTemp = Abc_NtkToNetlist( pNtk );
397 Abc_NtkDelete( pNtkCopy );
398 }
399 if ( !Abc_NtkToSop( pNtkTemp, 1, ABC_INFINITY ) )
400 return;
401 }
402 else if ( FileType == IO_FILE_MOPLA )
403 {
404 pNtkTemp = Abc_NtkStrash( pNtk, 0, 0, 0 );
405 }
406 else if ( FileType == IO_FILE_BENCH )
407 {
408 if ( !Abc_NtkIsStrash(pNtk) )
409 {
410 fprintf( stdout, "Writing traditional BENCH is available for AIGs only (use \"write_bench\").\n" );
411 return;
412 }
413 pNtkTemp = Abc_NtkToNetlistBench( pNtk );
414 }
415 else if ( FileType == IO_FILE_SMV )
416 {
417 if ( !Abc_NtkIsStrash(pNtk) )
418 {
419 fprintf( stdout, "Writing traditional SMV is available for AIGs only.\n" );
420 return;
421 }
422 pNtkTemp = Abc_NtkToNetlistBench( pNtk );
423 }
424 else
425 pNtkTemp = Abc_NtkToNetlist( pNtk );
426
427 if ( pNtkTemp == NULL )
428 {
429 fprintf( stdout, "Converting to netlist has failed.\n" );
430 return;
431 }
432
433 if ( FileType == IO_FILE_BLIF )
434 {
435 if ( !Abc_NtkHasSop(pNtkTemp) && !Abc_NtkHasMapping(pNtkTemp) )
436 Abc_NtkToSop( pNtkTemp, -1, ABC_INFINITY );
437 Io_WriteBlif( pNtkTemp, pFileName, 1, 0, 0 );
438 }
439 else if ( FileType == IO_FILE_BLIFMV )
440 {
441 if ( !Abc_NtkConvertToBlifMv( pNtkTemp ) )
442 return;
443 Io_WriteBlifMv( pNtkTemp, pFileName );
444 }
445 else if ( FileType == IO_FILE_BENCH )
446 Io_WriteBench( pNtkTemp, pFileName );
447 else if ( FileType == IO_FILE_BOOK )
448 Io_WriteBook( pNtkTemp, pFileName );
449 else if ( FileType == IO_FILE_PLA )
450 Io_WritePla( pNtkTemp, pFileName );
451 else if ( FileType == IO_FILE_MOPLA )
452 Io_WriteMoPla( pNtkTemp, pFileName );
453 else if ( FileType == IO_FILE_EQN )
454 {
455 if ( !Abc_NtkHasAig(pNtkTemp) )
456 Abc_NtkToAig( pNtkTemp );
457 Io_WriteEqn( pNtkTemp, pFileName );
458 }
459 else if ( FileType == IO_FILE_SMV )
460 Io_WriteSmv( pNtkTemp, pFileName );
461 else if ( FileType == IO_FILE_VERILOG )
462 {
463 if ( !Abc_NtkHasAig(pNtkTemp) && !Abc_NtkHasMapping(pNtkTemp) )
464 Abc_NtkToAig( pNtkTemp );
465 Io_WriteVerilog( pNtkTemp, pFileName, 0 );
466 }
467 else
468 fprintf( stderr, "Unknown file format.\n" );
469 Abc_NtkDelete( pNtkTemp );
470 }
471
472 /**Function*************************************************************
473
474 Synopsis [Write the network into file.]
475
476 Description []
477
478 SideEffects []
479
480 SeeAlso []
481
482 ***********************************************************************/
Io_WriteHie(Abc_Ntk_t * pNtk,char * pBaseName,char * pFileName)483 void Io_WriteHie( Abc_Ntk_t * pNtk, char * pBaseName, char * pFileName )
484 {
485 Abc_Ntk_t * pNtkTemp, * pNtkResult, * pNtkBase = NULL;
486 int i;
487 // check if the current network is available
488 if ( pNtk == NULL )
489 {
490 fprintf( stdout, "Empty network.\n" );
491 return;
492 }
493
494 // read the base network
495 assert( Abc_NtkIsStrash(pNtk) || Abc_NtkIsLogic(pNtk) );
496 if ( Io_ReadFileType(pBaseName) == IO_FILE_BLIF )
497 pNtkBase = Io_ReadBlifMv( pBaseName, 0, 1 );
498 else if ( Io_ReadFileType(pBaseName) == IO_FILE_BLIFMV )
499 pNtkBase = Io_ReadBlifMv( pBaseName, 1, 1 );
500 else if ( Io_ReadFileType(pBaseName) == IO_FILE_VERILOG )
501 pNtkBase = Io_ReadVerilog( pBaseName, 1 );
502 else
503 fprintf( stderr, "Unknown input file format.\n" );
504 if ( pNtkBase == NULL )
505 return;
506
507 // flatten logic hierarchy if present
508 if ( Abc_NtkWhiteboxNum(pNtkBase) > 0 && pNtk->nBarBufs == 0 )
509 {
510 pNtkBase = Abc_NtkFlattenLogicHierarchy( pNtkTemp = pNtkBase );
511 Abc_NtkDelete( pNtkTemp );
512 if ( pNtkBase == NULL )
513 return;
514 }
515
516 // reintroduce the boxes into the netlist
517 if ( pNtk->nBarBufs > 0 )
518 {
519 // derive the netlist
520 pNtkResult = Abc_NtkToNetlist( pNtk );
521 pNtkResult = Abc_NtkFromBarBufs( pNtkBase, pNtkTemp = pNtkResult );
522 Abc_NtkDelete( pNtkTemp );
523 if ( pNtkResult )
524 printf( "Hierarchy writer replaced %d barbufs by hierarchy boundaries.\n", pNtk->nBarBufs );
525 }
526 else if ( Io_ReadFileType(pBaseName) == IO_FILE_BLIFMV )
527 {
528 if ( Abc_NtkBlackboxNum(pNtkBase) > 0 )
529 {
530 printf( "Hierarchy writer does not support BLIF-MV with blackboxes.\n" );
531 Abc_NtkDelete( pNtkBase );
532 return;
533 }
534 // convert the current network to BLIF-MV
535 assert( !Abc_NtkIsNetlist(pNtk) );
536 pNtkResult = Abc_NtkToNetlist( pNtk );
537 if ( !Abc_NtkConvertToBlifMv( pNtkResult ) )
538 {
539 Abc_NtkDelete( pNtkBase );
540 return;
541 }
542 // reintroduce the network
543 pNtkResult = Abc_NtkInsertBlifMv( pNtkBase, pNtkTemp = pNtkResult );
544 Abc_NtkDelete( pNtkTemp );
545 }
546 else if ( Abc_NtkBlackboxNum(pNtkBase) > 0 )
547 {
548 // derive the netlist
549 pNtkResult = Abc_NtkToNetlist( pNtk );
550 pNtkResult = Abc_NtkInsertNewLogic( pNtkBase, pNtkTemp = pNtkResult );
551 Abc_NtkDelete( pNtkTemp );
552 if ( pNtkResult )
553 printf( "Hierarchy writer reintroduced %d instances of blackboxes.\n", Abc_NtkBlackboxNum(pNtkBase) );
554 }
555 else
556 {
557 printf( "Warning: The output network does not contain blackboxes.\n" );
558 pNtkResult = Abc_NtkToNetlist( pNtk );
559 }
560 Abc_NtkDelete( pNtkBase );
561 if ( pNtkResult == NULL )
562 return;
563
564 // write the resulting network
565 if ( Io_ReadFileType(pFileName) == IO_FILE_BLIF )
566 {
567 if ( pNtkResult->pDesign )
568 {
569 Vec_PtrForEachEntry( Abc_Ntk_t *, pNtkResult->pDesign->vModules, pNtkTemp, i )
570 if ( !Abc_NtkHasSop(pNtkTemp) && !Abc_NtkHasMapping(pNtkTemp) )
571 Abc_NtkToSop( pNtkTemp, -1, ABC_INFINITY );
572 }
573 else
574 {
575 if ( !Abc_NtkHasSop(pNtkResult) && !Abc_NtkHasMapping(pNtkResult) )
576 Abc_NtkToSop( pNtkResult, -1, ABC_INFINITY );
577 }
578 Io_WriteBlif( pNtkResult, pFileName, 1, 0, 0 );
579 }
580 else if ( Io_ReadFileType(pFileName) == IO_FILE_VERILOG )
581 {
582 if ( pNtkResult->pDesign )
583 {
584 Vec_PtrForEachEntry( Abc_Ntk_t *, pNtkResult->pDesign->vModules, pNtkTemp, i )
585 if ( !Abc_NtkHasAig(pNtkTemp) && !Abc_NtkHasMapping(pNtkTemp) )
586 Abc_NtkToAig( pNtkTemp );
587 }
588 else
589 {
590 if ( !Abc_NtkHasAig(pNtkResult) && !Abc_NtkHasMapping(pNtkResult) )
591 Abc_NtkToAig( pNtkResult );
592 }
593 Io_WriteVerilog( pNtkResult, pFileName, 0 );
594 }
595 else if ( Io_ReadFileType(pFileName) == IO_FILE_BLIFMV )
596 {
597 Io_WriteBlifMv( pNtkResult, pFileName );
598 }
599 else
600 fprintf( stderr, "Unknown output file format.\n" );
601
602 Abc_NtkDelete( pNtkResult );
603 }
604
605 /**Function*************************************************************
606
607 Synopsis [Creates PI terminal and net.]
608
609 Description []
610
611 SideEffects []
612
613 SeeAlso []
614
615 ***********************************************************************/
Io_ReadCreatePi(Abc_Ntk_t * pNtk,char * pName)616 Abc_Obj_t * Io_ReadCreatePi( Abc_Ntk_t * pNtk, char * pName )
617 {
618 Abc_Obj_t * pNet, * pTerm;
619 // get the PI net
620 pNet = Abc_NtkFindNet( pNtk, pName );
621 if ( pNet )
622 printf( "Warning: PI \"%s\" appears twice in the list.\n", pName );
623 pNet = Abc_NtkFindOrCreateNet( pNtk, pName );
624 // add the PI node
625 pTerm = Abc_NtkCreatePi( pNtk );
626 Abc_ObjAddFanin( pNet, pTerm );
627 return pTerm;
628 }
629
630 /**Function*************************************************************
631
632 Synopsis [Creates PO terminal and net.]
633
634 Description []
635
636 SideEffects []
637
638 SeeAlso []
639
640 ***********************************************************************/
Io_ReadCreatePo(Abc_Ntk_t * pNtk,char * pName)641 Abc_Obj_t * Io_ReadCreatePo( Abc_Ntk_t * pNtk, char * pName )
642 {
643 Abc_Obj_t * pNet, * pTerm;
644 // get the PO net
645 pNet = Abc_NtkFindNet( pNtk, pName );
646 if ( pNet && Abc_ObjFaninNum(pNet) == 0 )
647 printf( "Warning: PO \"%s\" appears twice in the list.\n", pName );
648 pNet = Abc_NtkFindOrCreateNet( pNtk, pName );
649 // add the PO node
650 pTerm = Abc_NtkCreatePo( pNtk );
651 Abc_ObjAddFanin( pTerm, pNet );
652 return pTerm;
653 }
654
655 /**Function*************************************************************
656
657 Synopsis [Create a latch with the given input/output.]
658
659 Description [By default, the latch value is unknown (ABC_INIT_NONE).]
660
661 SideEffects []
662
663 SeeAlso []
664
665 ***********************************************************************/
Io_ReadCreateLatch(Abc_Ntk_t * pNtk,char * pNetLI,char * pNetLO)666 Abc_Obj_t * Io_ReadCreateLatch( Abc_Ntk_t * pNtk, char * pNetLI, char * pNetLO )
667 {
668 Abc_Obj_t * pLatch, * pTerm, * pNet;
669 // get the LI net
670 pNet = Abc_NtkFindOrCreateNet( pNtk, pNetLI );
671 // add the BO terminal
672 pTerm = Abc_NtkCreateBi( pNtk );
673 Abc_ObjAddFanin( pTerm, pNet );
674 // add the latch box
675 pLatch = Abc_NtkCreateLatch( pNtk );
676 Abc_ObjAddFanin( pLatch, pTerm );
677 // add the BI terminal
678 pTerm = Abc_NtkCreateBo( pNtk );
679 Abc_ObjAddFanin( pTerm, pLatch );
680 // get the LO net
681 pNet = Abc_NtkFindOrCreateNet( pNtk, pNetLO );
682 Abc_ObjAddFanin( pNet, pTerm );
683 // set latch name
684 Abc_ObjAssignName( pLatch, pNetLO, "L" );
685 return pLatch;
686 }
687
688 /**Function*************************************************************
689
690 Synopsis [Create the reset latch with data=1 and init=0.]
691
692 Description []
693
694 SideEffects []
695
696 SeeAlso []
697
698 ***********************************************************************/
Io_ReadCreateResetLatch(Abc_Ntk_t * pNtk,int fBlifMv)699 Abc_Obj_t * Io_ReadCreateResetLatch( Abc_Ntk_t * pNtk, int fBlifMv )
700 {
701 Abc_Obj_t * pLatch, * pNode;
702 Abc_Obj_t * pNetLI, * pNetLO;
703 // create latch with 0 init value
704 // pLatch = Io_ReadCreateLatch( pNtk, "_resetLI_", "_resetLO_" );
705 pNetLI = Abc_NtkCreateNet( pNtk );
706 pNetLO = Abc_NtkCreateNet( pNtk );
707 Abc_ObjAssignName( pNetLI, Abc_ObjName(pNetLI), NULL );
708 Abc_ObjAssignName( pNetLO, Abc_ObjName(pNetLO), NULL );
709 pLatch = Io_ReadCreateLatch( pNtk, Abc_ObjName(pNetLI), Abc_ObjName(pNetLO) );
710 // set the initial value
711 Abc_LatchSetInit0( pLatch );
712 // feed the latch with constant1- node
713 // pNode = Abc_NtkCreateNode( pNtk );
714 // pNode->pData = Abc_SopRegister( (Extra_MmFlex_t *)pNtk->pManFunc, "2\n1\n" );
715 pNode = Abc_NtkCreateNodeConst1( pNtk );
716 Abc_ObjAddFanin( Abc_ObjFanin0(Abc_ObjFanin0(pLatch)), pNode );
717 return pLatch;
718 }
719
720 /**Function*************************************************************
721
722 Synopsis [Create node and the net driven by it.]
723
724 Description []
725
726 SideEffects []
727
728 SeeAlso []
729
730 ***********************************************************************/
Io_ReadCreateNode(Abc_Ntk_t * pNtk,char * pNameOut,char * pNamesIn[],int nInputs)731 Abc_Obj_t * Io_ReadCreateNode( Abc_Ntk_t * pNtk, char * pNameOut, char * pNamesIn[], int nInputs )
732 {
733 Abc_Obj_t * pNet, * pNode;
734 int i;
735 // create a new node
736 pNode = Abc_NtkCreateNode( pNtk );
737 // add the fanin nets
738 for ( i = 0; i < nInputs; i++ )
739 {
740 pNet = Abc_NtkFindOrCreateNet( pNtk, pNamesIn[i] );
741 Abc_ObjAddFanin( pNode, pNet );
742 }
743 // add the fanout net
744 pNet = Abc_NtkFindOrCreateNet( pNtk, pNameOut );
745 Abc_ObjAddFanin( pNet, pNode );
746 return pNode;
747 }
748
749 /**Function*************************************************************
750
751 Synopsis [Create a constant 0 node driving the net with this name.]
752
753 Description [Assumes that the net already exists.]
754
755 SideEffects []
756
757 SeeAlso []
758
759 ***********************************************************************/
Io_ReadCreateConst(Abc_Ntk_t * pNtk,char * pName,int fConst1)760 Abc_Obj_t * Io_ReadCreateConst( Abc_Ntk_t * pNtk, char * pName, int fConst1 )
761 {
762 Abc_Obj_t * pNet, * pTerm;
763 pTerm = fConst1? Abc_NtkCreateNodeConst1(pNtk) : Abc_NtkCreateNodeConst0(pNtk);
764 pNet = Abc_NtkFindNet(pNtk, pName); assert( pNet );
765 Abc_ObjAddFanin( pNet, pTerm );
766 return pTerm;
767 }
768
769 /**Function*************************************************************
770
771 Synopsis [Create an inverter or buffer for the given net.]
772
773 Description [Assumes that the nets already exist.]
774
775 SideEffects []
776
777 SeeAlso []
778
779 ***********************************************************************/
Io_ReadCreateInv(Abc_Ntk_t * pNtk,char * pNameIn,char * pNameOut)780 Abc_Obj_t * Io_ReadCreateInv( Abc_Ntk_t * pNtk, char * pNameIn, char * pNameOut )
781 {
782 Abc_Obj_t * pNet, * pNode;
783 pNet = Abc_NtkFindNet(pNtk, pNameIn); assert( pNet );
784 pNode = Abc_NtkCreateNodeInv(pNtk, pNet);
785 pNet = Abc_NtkFindNet(pNtk, pNameOut); assert( pNet );
786 Abc_ObjAddFanin( pNet, pNode );
787 return pNode;
788 }
789
790 /**Function*************************************************************
791
792 Synopsis [Create an inverter or buffer for the given net.]
793
794 Description [Assumes that the nets already exist.]
795
796 SideEffects []
797
798 SeeAlso []
799
800 ***********************************************************************/
Io_ReadCreateBuf(Abc_Ntk_t * pNtk,char * pNameIn,char * pNameOut)801 Abc_Obj_t * Io_ReadCreateBuf( Abc_Ntk_t * pNtk, char * pNameIn, char * pNameOut )
802 {
803 Abc_Obj_t * pNet, * pNode;
804 pNet = Abc_NtkFindNet(pNtk, pNameIn); assert( pNet );
805 pNode = Abc_NtkCreateNodeBuf(pNtk, pNet);
806 pNet = Abc_NtkFindNet(pNtk, pNameOut); assert( pNet );
807 Abc_ObjAddFanin( pNet, pNode );
808 return pNet;
809 }
810
811
812 /**Function*************************************************************
813
814 Synopsis [Provide an fopen replacement with path lookup]
815
816 Description [Provide an fopen replacement where the path stored
817 in pathvar MVSIS variable is used to look up the path
818 for name. Returns NULL if file cannot be opened.]
819
820 SideEffects []
821
822 SeeAlso []
823
824 ***********************************************************************/
Io_FileOpen(const char * FileName,const char * PathVar,const char * Mode,int fVerbose)825 FILE * Io_FileOpen( const char * FileName, const char * PathVar, const char * Mode, int fVerbose )
826 {
827 char * t = 0, * c = 0, * i;
828
829 if ( PathVar == 0 )
830 {
831 return fopen( FileName, Mode );
832 }
833 else
834 {
835 if ( (c = Abc_FrameReadFlag( (char*)PathVar )) )
836 {
837 char ActualFileName[4096];
838 FILE * fp = 0;
839 t = Extra_UtilStrsav( c );
840 for (i = strtok( t, ":" ); i != 0; i = strtok( 0, ":") )
841 {
842 #ifdef WIN32
843 _snprintf ( ActualFileName, 4096, "%s/%s", i, FileName );
844 #else
845 snprintf ( ActualFileName, 4096, "%s/%s", i, FileName );
846 #endif
847 if ( ( fp = fopen ( ActualFileName, Mode ) ) )
848 {
849 if ( fVerbose )
850 fprintf ( stdout, "Using file %s\n", ActualFileName );
851 ABC_FREE( t );
852 return fp;
853 }
854 }
855 ABC_FREE( t );
856 return 0;
857 }
858 else
859 {
860 return fopen( FileName, Mode );
861 }
862 }
863 }
864
865 ////////////////////////////////////////////////////////////////////////
866 /// END OF FILE ///
867 ////////////////////////////////////////////////////////////////////////
868
869
870 ABC_NAMESPACE_IMPL_END
871
872