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