ABC: A System for Sequential Synthesis and Verification
 
Loading...
Searching...
No Matches
Functions
cbaWriteVer.c File Reference
#include "cba.h"
#include "cbaPrs.h"
#include "map/mio/mio.h"
#include "base/main/main.h"
Include dependency graph for cbaWriteVer.c:

Go to the source code of this file.

Functions

ABC_NAMESPACE_IMPL_START void Cba_ManCreatePrimMap (char **pMap)
 DECLARATIONS ///.
 
char * Prs_ObjGetName (Prs_Ntk_t *p, int NameId)
 
void Prs_ManWriteVerilogArray (FILE *pFile, Prs_Ntk_t *p, Vec_Int_t *vSigs, int fOdd)
 
void Prs_ManWriteVerilog (char *pFileName, Vec_Ptr_t *vPrs)
 
char * Cba_ObjGetName (Cba_Ntk_t *p, int i)
 
char * Cba_FonGetName (Cba_Ntk_t *p, int i)
 
char * Cba_ManGetSliceName (Cba_Ntk_t *p, int iFon, int RangeId)
 
void Cba_ManWriteFonRange (Cba_Ntk_t *p, int iFon)
 
void Cba_ManWriteFonName (Cba_Ntk_t *p, int iFon, int fInlineConcat, int fInput)
 
void Cba_ManWriteConcat (Cba_Ntk_t *p, int iObj)
 
int Cba_ManWriteLineFile (Cba_Ntk_t *p, int iObj, int FileAttr, int LineAttr)
 
void Cba_ManWriteVerilogNtk (Cba_Ntk_t *p, int fInlineConcat)
 
void Cba_ManWriteVerilog (char *pFileName, Cba_Man_t *p, int fInlineConcat)
 

Function Documentation

◆ Cba_FonGetName()

char * Cba_FonGetName ( Cba_Ntk_t * p,
int i )

Definition at line 370 of file cbaWriteVer.c.

371{
372 char * pName = Cba_FonNameStr(p, i);
373 if ( pName == NULL )
374 return pName;
375 if ( Cba_ObjType(p, Cba_FonObj(p, i)) == CBA_BOX_SLICE )
376 return pName;
377 if ( Cba_NameIsLegalInVerilog(pName, Cba_FonName(p, i)) )
378 return pName;
379 return Vec_StrPrintF( Abc_NamBuffer(Cba_NtkNam(p)), "\\%s ", pName );
380}
CBA_BOX_SLICE
@ CBA_BOX_SLICE
Definition cbaTypes.h:141
p
Cube * p
Definition exorList.c:222
Abc_NamBuffer
Vec_Str_t * Abc_NamBuffer(Abc_Nam_t *p)
Definition utilNam.c:571
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Cba_ManCreatePrimMap()

ABC_NAMESPACE_IMPL_START void Cba_ManCreatePrimMap ( char ** pMap)

DECLARATIONS ///.

CFile****************************************************************

FileName [cbaWriteVer.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Hierarchical word-level netlist.]

Synopsis [Verilog writer.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - November 29, 2014.]

Revision [

Id
cbaWriteVer.c,v 1.00 2014/11/29 00:00:00 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 47 of file cbaWriteVer.c.

48{
49 memset( pMap, 0, sizeof(char *) * CBA_BOX_LAST );
50
51 pMap[ CBA_BOX_SLICE ] = "sli";
52 pMap[ CBA_BOX_CONCAT ] = "icc";
53
54 pMap[ CBA_BOX_BUF ] = "";
55 pMap[ CBA_BOX_INV ] = "~";
56 pMap[ CBA_BOX_AND ] = "&";
57 pMap[ CBA_BOX_NAND ] = "&";
58 pMap[ CBA_BOX_OR ] = "|";
59 pMap[ CBA_BOX_NOR ] = "|";
60 pMap[ CBA_BOX_XOR ] = "^";
61 pMap[ CBA_BOX_XNOR ] = "^";
62 pMap[ CBA_BOX_SHARP ] = "&";
63 pMap[ CBA_BOX_SHARPL ] = "&";
64 pMap[ CBA_BOX_MUX ] = "?";
65 pMap[ CBA_BOX_MAJ ] = "maj";
66 pMap[ CBA_BOX_RAND ] = "&";
67 pMap[ CBA_BOX_RNAND ] = "~&";
68 pMap[ CBA_BOX_ROR ] = "|";
69 pMap[ CBA_BOX_RNOR ] = "~|";
70 pMap[ CBA_BOX_RXOR ] = "^";
71 pMap[ CBA_BOX_RXNOR ] = "~^";
72 pMap[ CBA_BOX_LNOT ] = "!";
73 pMap[ CBA_BOX_LAND ] = "&&";
74 pMap[ CBA_BOX_LNAND ] = "logic nand";
75 pMap[ CBA_BOX_LOR ] = "||";
76 pMap[ CBA_BOX_LNOR ] = "logic nor";
77 pMap[ CBA_BOX_LXOR ] = "^^";
78 pMap[ CBA_BOX_LXNOR ] = "logic xnor";
79 pMap[ CBA_BOX_NMUX ] = "nmux";
80 pMap[ CBA_BOX_SEL ] = "sel";
81 pMap[ CBA_BOX_PSEL ] = "prio-select";
82 pMap[ CBA_BOX_ENC ] = "enc";
83 pMap[ CBA_BOX_PENC ] = "prio-enc";
84 pMap[ CBA_BOX_DEC ] = "dec";
85 pMap[ CBA_BOX_EDEC ] = "enable-dec";
86 pMap[ CBA_BOX_ADD ] = "+";
87 pMap[ CBA_BOX_SUB ] = "-";
88 pMap[ CBA_BOX_MUL ] = "*";
89 pMap[ CBA_BOX_DIV ] = "/";
90 pMap[ CBA_BOX_MOD ] = "%";
91 pMap[ CBA_BOX_REM ] = "%";
92 pMap[ CBA_BOX_POW ] = "**";
93 pMap[ CBA_BOX_MIN ] = "-";
94 pMap[ CBA_BOX_SQRT ] = "@";
95 pMap[ CBA_BOX_ABS ] = "abs";
96 pMap[ CBA_BOX_LTHAN ] = "<";
97 pMap[ CBA_BOX_LETHAN ] = "<=";
98 pMap[ CBA_BOX_METHAN ] = ">=";
99 pMap[ CBA_BOX_MTHAN ] = ">";
100 pMap[ CBA_BOX_EQU ] = "==";
101 pMap[ CBA_BOX_NEQU ] = "!=";
102 pMap[ CBA_BOX_SHIL ] = "<<";
103 pMap[ CBA_BOX_SHIR ] = ">>";
104 pMap[ CBA_BOX_SHILA ] = "<<<";
105 pMap[ CBA_BOX_SHIRA ] = ">>>";
106 pMap[ CBA_BOX_ROTL ] = "rotL";
107 pMap[ CBA_BOX_ROTR ] = "rotR";
108
109 pMap[ CBA_BOX_TRI ] = "tri";
110 pMap[ CBA_BOX_RAM ] = "ram";
111 pMap[ CBA_BOX_RAMR ] = "ramR";
112 pMap[ CBA_BOX_RAMW ] = "ramW";
113 pMap[ CBA_BOX_RAMWC ] = "ramWC";
114 pMap[ CBA_BOX_RAMBOX ] = "ramBox";
115
116 pMap[ CBA_BOX_LATCH ] = "lat";
117 pMap[ CBA_BOX_LATCHRS] = "latrs";
118 pMap[ CBA_BOX_DFF ] = "dff";
119 pMap[ CBA_BOX_DFFRS ] = "dffrs";
120}
CBA_BOX_RNAND
@ CBA_BOX_RNAND
Definition cbaTypes.h:72
CBA_BOX_RAMW
@ CBA_BOX_RAMW
Definition cbaTypes.h:129
CBA_BOX_SHIRA
@ CBA_BOX_SHIRA
Definition cbaTypes.h:117
CBA_BOX_NEQU
@ CBA_BOX_NEQU
Definition cbaTypes.h:112
CBA_BOX_LXNOR
@ CBA_BOX_LXNOR
Definition cbaTypes.h:84
CBA_BOX_INV
@ CBA_BOX_INV
Definition cbaTypes.h:51
CBA_BOX_LTHAN
@ CBA_BOX_LTHAN
Definition cbaTypes.h:107
CBA_BOX_MUL
@ CBA_BOX_MUL
Definition cbaTypes.h:96
CBA_BOX_NOR
@ CBA_BOX_NOR
Definition cbaTypes.h:55
CBA_BOX_MOD
@ CBA_BOX_MOD
Definition cbaTypes.h:99
CBA_BOX_DIV
@ CBA_BOX_DIV
Definition cbaTypes.h:98
CBA_BOX_XNOR
@ CBA_BOX_XNOR
Definition cbaTypes.h:57
CBA_BOX_LOR
@ CBA_BOX_LOR
Definition cbaTypes.h:81
CBA_BOX_LNOR
@ CBA_BOX_LNOR
Definition cbaTypes.h:82
CBA_BOX_PENC
@ CBA_BOX_PENC
Definition cbaTypes.h:90
CBA_BOX_RAM
@ CBA_BOX_RAM
Definition cbaTypes.h:127
CBA_BOX_LNOT
@ CBA_BOX_LNOT
Definition cbaTypes.h:78
CBA_BOX_LNAND
@ CBA_BOX_LNAND
Definition cbaTypes.h:80
CBA_BOX_SHARP
@ CBA_BOX_SHARP
Definition cbaTypes.h:58
CBA_BOX_RXOR
@ CBA_BOX_RXOR
Definition cbaTypes.h:75
CBA_BOX_BUF
@ CBA_BOX_BUF
Definition cbaTypes.h:50
CBA_BOX_SHIL
@ CBA_BOX_SHIL
Definition cbaTypes.h:114
CBA_BOX_RAMBOX
@ CBA_BOX_RAMBOX
Definition cbaTypes.h:133
CBA_BOX_METHAN
@ CBA_BOX_METHAN
Definition cbaTypes.h:109
CBA_BOX_SHILA
@ CBA_BOX_SHILA
Definition cbaTypes.h:116
CBA_BOX_RAMR
@ CBA_BOX_RAMR
Definition cbaTypes.h:128
CBA_BOX_ENC
@ CBA_BOX_ENC
Definition cbaTypes.h:89
CBA_BOX_SHIR
@ CBA_BOX_SHIR
Definition cbaTypes.h:115
CBA_BOX_NMUX
@ CBA_BOX_NMUX
Definition cbaTypes.h:86
CBA_BOX_MIN
@ CBA_BOX_MIN
Definition cbaTypes.h:102
CBA_BOX_REM
@ CBA_BOX_REM
Definition cbaTypes.h:100
CBA_BOX_LATCHRS
@ CBA_BOX_LATCHRS
Definition cbaTypes.h:136
CBA_BOX_NAND
@ CBA_BOX_NAND
Definition cbaTypes.h:53
CBA_BOX_RNOR
@ CBA_BOX_RNOR
Definition cbaTypes.h:74
CBA_BOX_MUX
@ CBA_BOX_MUX
Definition cbaTypes.h:60
CBA_BOX_RXNOR
@ CBA_BOX_RXNOR
Definition cbaTypes.h:76
CBA_BOX_ROTR
@ CBA_BOX_ROTR
Definition cbaTypes.h:119
CBA_BOX_PSEL
@ CBA_BOX_PSEL
Definition cbaTypes.h:88
CBA_BOX_SEL
@ CBA_BOX_SEL
Definition cbaTypes.h:87
CBA_BOX_ROTL
@ CBA_BOX_ROTL
Definition cbaTypes.h:118
CBA_BOX_ABS
@ CBA_BOX_ABS
Definition cbaTypes.h:104
CBA_BOX_RAMWC
@ CBA_BOX_RAMWC
Definition cbaTypes.h:130
CBA_BOX_SHARPL
@ CBA_BOX_SHARPL
Definition cbaTypes.h:59
CBA_BOX_LAST
@ CBA_BOX_LAST
Definition cbaTypes.h:144
CBA_BOX_POW
@ CBA_BOX_POW
Definition cbaTypes.h:101
CBA_BOX_TRI
@ CBA_BOX_TRI
Definition cbaTypes.h:126
CBA_BOX_ROR
@ CBA_BOX_ROR
Definition cbaTypes.h:73
CBA_BOX_SQRT
@ CBA_BOX_SQRT
Definition cbaTypes.h:103
CBA_BOX_EQU
@ CBA_BOX_EQU
Definition cbaTypes.h:111
CBA_BOX_LETHAN
@ CBA_BOX_LETHAN
Definition cbaTypes.h:108
CBA_BOX_RAND
@ CBA_BOX_RAND
Definition cbaTypes.h:71
CBA_BOX_AND
@ CBA_BOX_AND
Definition cbaTypes.h:52
CBA_BOX_EDEC
@ CBA_BOX_EDEC
Definition cbaTypes.h:92
CBA_BOX_LAND
@ CBA_BOX_LAND
Definition cbaTypes.h:79
CBA_BOX_LATCH
@ CBA_BOX_LATCH
Definition cbaTypes.h:135
CBA_BOX_ADD
@ CBA_BOX_ADD
Definition cbaTypes.h:94
CBA_BOX_OR
@ CBA_BOX_OR
Definition cbaTypes.h:54
CBA_BOX_DFFRS
@ CBA_BOX_DFFRS
Definition cbaTypes.h:139
CBA_BOX_DFF
@ CBA_BOX_DFF
Definition cbaTypes.h:137
CBA_BOX_MTHAN
@ CBA_BOX_MTHAN
Definition cbaTypes.h:110
CBA_BOX_MAJ
@ CBA_BOX_MAJ
Definition cbaTypes.h:61
CBA_BOX_CONCAT
@ CBA_BOX_CONCAT
Definition cbaTypes.h:142
CBA_BOX_DEC
@ CBA_BOX_DEC
Definition cbaTypes.h:91
CBA_BOX_LXOR
@ CBA_BOX_LXOR
Definition cbaTypes.h:83
CBA_BOX_SUB
@ CBA_BOX_SUB
Definition cbaTypes.h:95
CBA_BOX_XOR
@ CBA_BOX_XOR
Definition cbaTypes.h:56
memset
char * memset()
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Cba_ManGetSliceName()

char * Cba_ManGetSliceName ( Cba_Ntk_t * p,
int iFon,
int RangeId )

Definition at line 381 of file cbaWriteVer.c.

382{
383 int Left = Cba_NtkRangeLeft(p, RangeId);
384 int Right = Cba_NtkRangeRight(p, RangeId);
385 char * pName = Cba_FonNameStr(p, iFon);
386 if ( Cba_NameIsLegalInVerilog(pName, Cba_FonName(p, iFon)) )
387 if ( Left == Right )
388 return Vec_StrPrintF( Abc_NamBuffer(Cba_NtkNam(p)), "%s[%d]", pName, Right );
389 else
390 return Vec_StrPrintF( Abc_NamBuffer(Cba_NtkNam(p)), "%s[%d:%d]", pName, Left, Right );
391 else
392 if ( Left == Right )
393 return Vec_StrPrintF( Abc_NamBuffer(Cba_NtkNam(p)), "\\%s [%d]", pName, Right );
394 else
395 return Vec_StrPrintF( Abc_NamBuffer(Cba_NtkNam(p)), "\\%s [%d:%d]", pName, Left, Right );
396}
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Cba_ManWriteConcat()

void Cba_ManWriteConcat ( Cba_Ntk_t * p,
int iObj )

Definition at line 426 of file cbaWriteVer.c.

427{
428 int i, iFin, iFon;
429 Vec_Str_t * vStr = &p->pDesign->vOut;
430 assert( Cba_ObjIsConcat(p, iObj) );
431 Vec_StrPush( vStr, '{' );
432 Cba_ObjForEachFinFon( p, iObj, iFin, iFon, i )
433 {
434 Vec_StrPrintStr( vStr, i ? ", " : "" );
435 Cba_ManWriteFonName( p, iFon, 1, 0 );
436 }
437 Vec_StrPush( vStr, '}' );
438}
Vec_Str_t
struct Vec_Str_t_ Vec_Str_t
Definition bblif.c:46
Cba_ManWriteFonName
void Cba_ManWriteFonName(Cba_Ntk_t *p, int iFon, int fInlineConcat, int fInput)
Definition cbaWriteVer.c:407
Cba_ObjForEachFinFon
#define Cba_ObjForEachFinFon(p, iObj, iFin, iFon, k)
Definition cba.h:348
assert
#define assert(ex)
Definition util_old.h:213
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Cba_ManWriteFonName()

void Cba_ManWriteFonName ( Cba_Ntk_t * p,
int iFon,
int fInlineConcat,
int fInput )

Definition at line 407 of file cbaWriteVer.c.

408{
409 extern void Cba_ManWriteConcat( Cba_Ntk_t * p, int iObj );
410 Vec_Str_t * vStr = &p->pDesign->vOut;
411 if ( !iFon || (!Cba_FonIsConst(iFon) && !Cba_FonName(p, iFon)) )
412 Vec_StrPrintF( vStr, "Open_%d", Cba_NtkMan(p)->nOpens++ );
413// Vec_StrPrintF( vStr, "1\'b0" );
414 else if ( fInlineConcat && !Cba_FonIsConst(iFon) && Cba_ObjIsConcat(p, Cba_FonObj(p, iFon)) )
415 Cba_ManWriteConcat( p, Cba_FonObj(p, iFon) );
416 else
417 {
418 int Range = fInput ? Cba_FonRangeSize( p, iFon ) : 0;
419 if ( fInput && Range > 1 )
420 Vec_StrPush( vStr, '{' );
421 Vec_StrPrintStr( vStr, Cba_FonIsConst(iFon) ? Cba_NtkConst(p, Cba_FonConst(iFon)) : Cba_FonGetName(p, iFon) );
422 if ( fInput && Range > 1 )
423 Vec_StrPush( vStr, '}' );
424 }
425}
Cba_FonGetName
char * Cba_FonGetName(Cba_Ntk_t *p, int i)
Definition cbaWriteVer.c:370
Cba_ManWriteConcat
void Cba_ManWriteConcat(Cba_Ntk_t *p, int iObj)
Definition cbaWriteVer.c:426
Cba_Ntk_t
typedefABC_NAMESPACE_HEADER_START struct Cba_Ntk_t_ Cba_Ntk_t
INCLUDES ///.
Definition cba.h:45
fInput
int fInput
Definition exorList.c:221
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Cba_ManWriteFonRange()

void Cba_ManWriteFonRange ( Cba_Ntk_t * p,
int iFon )

Definition at line 398 of file cbaWriteVer.c.

399{
400 Vec_Str_t * vStr = &p->pDesign->vOut;
401 if ( !iFon || Cba_FonIsConst(iFon) || (Cba_FonRangeSize(p, iFon) == 1 && Cba_FonRight(p, iFon) == 0) )
402 return;
403 if ( Cba_FonSigned(p, iFon) )
404 Vec_StrPrintF( vStr, "signed " );
405 Vec_StrPrintF( vStr, "[%d:%d] ", Cba_FonLeft(p, iFon), Cba_FonRight(p, iFon) );
406}
Here is the caller graph for this function:

◆ Cba_ManWriteLineFile()

int Cba_ManWriteLineFile ( Cba_Ntk_t * p,
int iObj,
int FileAttr,
int LineAttr )

Definition at line 439 of file cbaWriteVer.c.

440{
441 Vec_Str_t * vStr = &p->pDesign->vOut;
442 int FileId = 0, LineId = 0;
443 if ( FileAttr && (FileId = Cba_ObjAttrValue(p, iObj, FileAttr)) )
444 {
445 LineId = Cba_ObjAttrValue(p, iObj, LineAttr);
446 Vec_StrPrintF( vStr, " // %s(%d)", Cba_NtkStr(p, FileId), LineId );
447 return 1;
448 }
449 return 0;
450}
Here is the caller graph for this function:

◆ Cba_ManWriteVerilog()

void Cba_ManWriteVerilog ( char * pFileName,
Cba_Man_t * p,
int fInlineConcat )

Definition at line 975 of file cbaWriteVer.c.

976{
977 Cba_Ntk_t * pNtk; int i;
978 // check the library
979 if ( p->pMioLib && p->pMioLib != Abc_FrameReadLibGen() )
980 {
981 printf( "Genlib library used in the mapped design is not longer a current library.\n" );
982 return;
983 }
984 Cba_ManCreatePrimMap( p->pTypeNames );
985 // derive the stream
986 p->nOpens = 1;
987 Vec_StrClear( &p->vOut );
988 Vec_StrClear( &p->vOut2 );
989 Vec_StrPrintStr( &p->vOut, "// Design \"" );
990 Vec_StrPrintStr( &p->vOut, Cba_ManName(p) );
991 Vec_StrPrintStr( &p->vOut, "\" written via CBA package in ABC on " );
992 Vec_StrPrintStr( &p->vOut, Extra_TimeStamp() );
993 Vec_StrPrintStr( &p->vOut, "\n\n" );
994 Cba_ManForEachNtk( p, pNtk, i )
995 Cba_ManWriteVerilogNtk( pNtk, fInlineConcat );
996 // dump into file
997 if ( Vec_StrSize(&p->vOut) > 0 )
998 {
999 FILE * pFile = fopen( pFileName, "wb" );
1000 if ( pFile == NULL )
1001 printf( "Cannot open file \"%s\" for writing.\n", pFileName );
1002 else
1003 {
1004 fwrite( Vec_StrArray(&p->vOut), 1, Vec_StrSize(&p->vOut), pFile );
1005 fclose( pFile );
1006 }
1007 }
1008}
Abc_FrameReadLibGen
ABC_DLL void * Abc_FrameReadLibGen()
Definition mainFrame.c:59
Cba_ManWriteVerilogNtk
void Cba_ManWriteVerilogNtk(Cba_Ntk_t *p, int fInlineConcat)
Definition cbaWriteVer.c:451
Cba_ManCreatePrimMap
ABC_NAMESPACE_IMPL_START void Cba_ManCreatePrimMap(char **pMap)
DECLARATIONS ///.
Definition cbaWriteVer.c:47
Cba_ManForEachNtk
#define Cba_ManForEachNtk(p, pNtk, i)
ITERATORS ///.
Definition cba.h:305
Extra_TimeStamp
char * Extra_TimeStamp()
Definition extraUtilFile.c:465
Here is the call graph for this function:

◆ Cba_ManWriteVerilogNtk()

void Cba_ManWriteVerilogNtk ( Cba_Ntk_t * p,
int fInlineConcat )

Definition at line 451 of file cbaWriteVer.c.

452{
453 Vec_Str_t * vStr = &p->pDesign->vOut;
454 int i, k, iObj, iFin, iFon, StartPos, Status;
455 int FileAttr = Cba_NtkStrId( p, "file" );
456 int LineAttr = Cba_NtkStrId( p, "line" );
457 int fUseNewLine = (int)(Cba_NtkPioNum(p) > 5);
458 // mark PO fons
459 Vec_Bit_t * vPoFons = Vec_BitStart( Cba_NtkFonNum(p)+1 );
460 Cba_NtkForEachPoDriverFon( p, iObj, iFon, i )
461 if ( Cba_FonIsReal(iFon) && Cba_FonName(p, iFon) == Cba_ObjName(p, iObj) )
462 Vec_BitWriteEntry( vPoFons, iFon, 1 );
463 // write header
464 Vec_StrPrintStr( vStr, "module " );
465 Vec_StrPrintStr( vStr, Cba_NtkName(p) );
466 Vec_StrPrintStr( vStr, fUseNewLine ? " (\n " : " ( " );
467 StartPos = Vec_StrSize(vStr);
468 Cba_NtkForEachPioOrder( p, iObj, i )
469 {
470 Vec_StrPrintStr( vStr, i ? ", " : "" );
471 if ( Vec_StrSize(vStr) > StartPos + 70 )
472 {
473 StartPos = Vec_StrSize(vStr);
474 Vec_StrPrintStr( vStr, "\n " );
475 }
476 Vec_StrPrintStr( vStr, Cba_ObjGetName(p, iObj) );
477 }
478 Vec_StrPrintStr( vStr, fUseNewLine ? "\n );" : " );" );
479 Cba_ManWriteLineFile( p, 0, FileAttr, LineAttr );
480 Vec_StrPrintStr( vStr, fUseNewLine ? "\n" : "\n\n" );
481 // write inputs/outputs
482 Cba_NtkForEachPioOrder( p, iObj, i )
483 {
484 int Offset = Vec_StrSize(vStr);
485 Vec_StrPrintStr( vStr, " " );
486 Vec_StrPrintStr( vStr, Cba_ObjIsPi(p, iObj) ? "input " : "output " );
487 Cba_ManWriteFonRange( p, Cba_ObjIsPi(p, iObj) ? Cba_ObjFon0(p, iObj) : Cba_ObjFinFon(p, iObj, 0) );
488 Vec_StrPrintStr( vStr, Cba_ObjGetName(p, iObj) );
489 Vec_StrPrintF( vStr, ";%*s", Offset + 40 - Vec_StrSize(vStr), "" );
490 Cba_ManWriteLineFile( p, iObj, FileAttr, LineAttr );
491 Vec_StrPush( vStr, '\n' );
492 }
493 Vec_StrPrintStr( vStr, "\n" );
494 // write objects
495 Cba_NtkForEachBox( p, iObj )
496 {
497// char * pNameNtk = Cba_NtkName(p);
498// char * pNameInst = Cba_ObjGetName(p, iObj);
499 int Type = Cba_ObjType(p, iObj);
500 if ( Cba_ObjIsSlice(p, iObj) )
501 continue;
502 if ( fInlineConcat && Cba_ObjIsConcat(p, iObj) )
503 continue;
504 if ( Cba_ObjIsBoxUser(p, iObj) )
505 {
506 Cba_Ntk_t * pNtk = Cba_ObjNtk(p, iObj);
507 // write output wire declarations
508 Cba_ObjForEachFon( p, iObj, iFon, i )
509 {
510 if ( Vec_BitEntry(vPoFons, iFon) )
511 continue;
512 Vec_StrPrintStr( vStr, " wire " );
513 Cba_ManWriteFonRange( p, iFon );
514 Cba_ManWriteFonName( p, iFon, 0, 0 );
515 Vec_StrPrintStr( vStr, ";\n" );
516 }
517 // write box
518 Vec_StrPrintStr( vStr, " " );
519 Vec_StrPrintStr( vStr, Cba_NtkName(pNtk) );
520 Vec_StrPush( vStr, ' ' );
521 if ( Cba_ObjName(p, iObj) )
522 Vec_StrPrintF( vStr, "%s ", Cba_ObjGetName(p, iObj) );
523 // write input binding
524 Vec_StrPrintStr( vStr, "( " );
525 Cba_ObjForEachFinFon( p, iObj, iFin, iFon, i )
526 {
527 Vec_StrPrintF( vStr, "%s.%s(", i ? ", " : "", Cba_ObjGetName(pNtk, Cba_NtkPi(pNtk, i)) );
528 Cba_ManWriteFonName( p, iFon, fInlineConcat, 1 );
529 Vec_StrPush( vStr, ')' );
530 }
531 // write output binding
532 Cba_ObjForEachFon( p, iObj, iFon, i )
533 {
534 Vec_StrPrintF( vStr, "%s.%s(", Cba_ObjFinNum(p, iObj) ? ", " : "", Cba_ObjGetName(pNtk, Cba_NtkPo(pNtk, i)) );
535 Cba_ManWriteFonName( p, iFon, 0, 1 );
536 Vec_StrPush( vStr, ')' );
537 }
538 Vec_StrPrintStr( vStr, ");" );
539 }
540 else if ( Type == CBA_BOX_RAMWC || Type == CBA_BOX_RAMBOX || Type == CBA_BOX_RAMR )
541 {
542 int Num = (Type == CBA_BOX_RAMWC) ? 0 : (Type == CBA_BOX_RAMR ? 1 : 2); // write / read / box
543 char * pBoxName[3] = { "RAM_WRITE", "RAM_READ", "RAM_BOX" };
544 char * pOutputs[3] = { "ram", "rdata", "out" };
545 char * pInputs[3][4] = { {"clk", "wen", "waddr", "wdata"}, {"ren", "raddr", "ram"}, {"in0", "in1", "in2", "in3"} };
546 // write declaration for the output
547 int iFonOut = Cba_ObjFon0(p, iObj);
548 if ( Vec_BitEntry(vPoFons, iFonOut) )
549 Vec_StrPrintStr( vStr, " assign " );
550 else
551 {
552 Vec_StrPrintStr( vStr, " wire " );
553 Cba_ManWriteFonRange( p, iFonOut );
554 }
555 Cba_ManWriteFonName( p, iFonOut, 0, 0 );
556 Vec_StrPrintStr( vStr, ";\n" );
557 // write box
558 Vec_StrPrintF( vStr, " %s( ", pBoxName[Num] );
559 Cba_ObjForEachFinFon( p, iObj, iFin, iFon, i )
560 {
561 Vec_StrPrintF( vStr, "%s.%s(", i ? ", " : "", pInputs[Num][i] );
562 Cba_ManWriteFonName( p, iFon, fInlineConcat, 1 );
563 Vec_StrPush( vStr, ')' );
564 }
565 Vec_StrPrintF( vStr, "%s.%s(", Cba_ObjFinNum(p, iObj) ? ", " : "", pOutputs[Num] );
566 Cba_ManWriteFonName( p, iFonOut, 0, 1 );
567 Vec_StrPrintStr( vStr, ") );" );
568 }
569 else if ( Type == CBA_BOX_NMUX || Type == CBA_BOX_SEL )
570 {
571 int fUseSel = Type == CBA_BOX_SEL;
572 int nBits = fUseSel ? Cba_ObjFinNum(p, iObj) - 1 : Abc_Base2Log(Cba_ObjFinNum(p, iObj) - 1);
573 int iFonIn = Cba_ObjFinFon(p, iObj, 0);
574 int iFonOut = Cba_ObjFon0(p, iObj);
575 // function [15:0] res;
576 Vec_StrPrintStr( vStr, " function " );
577 Cba_ManWriteFonRange( p, iFonOut );
578 Vec_StrPrintStr( vStr, "_func_" );
579 Cba_ManWriteFonName( p, iFonOut, 0, 0 );
580 Vec_StrPrintStr( vStr, ";\n" );
581 // input [1:0] s;
582 Vec_StrPrintStr( vStr, " input " );
583 Cba_ManWriteFonRange( p, iFonIn );
584 Vec_StrPrintStr( vStr, "s;\n" );
585 // input [15:0] d0, d1, d2, d3;
586 Vec_StrPrintStr( vStr, " input " );
587 Cba_ManWriteFonRange( p, iFonOut );
588 Cba_ObjForEachFinFon( p, iObj, iFin, iFon, i )
589 {
590 if ( i == 0 ) continue;
591 Vec_StrPrintF( vStr, "%sd%d", i > 1 ? ", " : "", i-1 );
592 }
593 Vec_StrPrintStr( vStr, ";\n" );
594 // casez (s)
595 Vec_StrPrintStr( vStr, " casez(s)" );
596 if ( fUseSel )
597 Vec_StrPrintStr( vStr, " // synopsys full_case parallel_case" );
598 Vec_StrPrintStr( vStr, "\n" );
599 // 2'b00: res = b[15:0];
600 Cba_ObjForEachFinFon( p, iObj, iFin, iFon, i )
601 {
602 if ( i == 0 ) continue;
603 Vec_StrPrintF( vStr, " %d\'b", nBits );
604 if ( fUseSel )
605 {
606 Vec_StrFillExtra( vStr, Vec_StrSize(vStr) + nBits, '?' );
607 Vec_StrWriteEntry( vStr, Vec_StrSize(vStr) - i, '1' );
608 }
609 else
610 {
611 for ( k = nBits-1; k >= 0; k-- )
612 Vec_StrPrintNum( vStr, ((i-1) >> k) & 1 );
613 }
614 Vec_StrPrintStr( vStr, ": _func_" );
615 Cba_ManWriteFonName( p, iFonOut, 0, 0 );
616 Vec_StrPrintF( vStr, " = d%d;\n", i-1 );
617 }
618 Vec_StrPrintStr( vStr, " endcase\n" );
619 Vec_StrPrintStr( vStr, " endfunction\n" );
620 // assign z = res(a, b, s);
621 if ( Vec_BitEntry(vPoFons, iFonOut) )
622 Vec_StrPrintStr( vStr, " assign " );
623 else
624 {
625 Vec_StrPrintStr( vStr, " wire " );
626 Cba_ManWriteFonRange( p, iFonOut );
627 }
628 Cba_ManWriteFonName( p, iFonOut, fInlineConcat, 0 );
629 Vec_StrPrintStr( vStr, " = _func_" );
630 Cba_ManWriteFonName( p, iFonOut, 0, 0 );
631 Vec_StrPrintStr( vStr, " ( " );
632 Cba_ObjForEachFinFon( p, iObj, iFin, iFon, i )
633 {
634 Vec_StrPrintStr( vStr, i ? ", " : "" );
635 Cba_ManWriteFonName( p, iFon, fInlineConcat, 0 );
636 }
637 Vec_StrPrintStr( vStr, " );" );
638 }
639 else if ( Type == CBA_BOX_DEC )
640 {
641 int iFonIn = Cba_ObjFinFon(p, iObj, 0);
642 int iFonOut = Cba_ObjFon0(p, iObj);
643 int nBitsIn = Cba_FonRangeSize(p, iFonIn);
644 int nBitsOut = Cba_FonRangeSize(p, iFonOut);
645 assert( (1 << nBitsIn) == nBitsOut );
646 // function [15:0] res;
647 Vec_StrPrintStr( vStr, " function " );
648 Cba_ManWriteFonRange( p, iFonOut );
649 Vec_StrPrintStr( vStr, "_func_" );
650 Cba_ManWriteFonName( p, iFonOut, 0, 0 );
651 Vec_StrPrintStr( vStr, ";\n" );
652 // input [1:0] i;
653 Vec_StrPrintStr( vStr, " input " );
654 Cba_ManWriteFonRange( p, iFonIn );
655 Vec_StrPrintStr( vStr, "i;\n" );
656 // casez (i)
657 Vec_StrPrintStr( vStr, " casez(i)\n" );
658 // 2'b00: res = 4'b0001;
659 for ( i = 0; i < (1 << nBitsIn); i++ )
660 {
661 Vec_StrPrintF( vStr, " %d\'b", nBitsIn );
662 for ( k = nBitsIn-1; k >= 0; k-- )
663 Vec_StrPrintNum( vStr, (i >> k) & 1 );
664 Vec_StrPrintStr( vStr, ": _func_" );
665 Cba_ManWriteFonName( p, iFonOut, 0, 0 );
666 Vec_StrPrintF( vStr, " = %d\'b%0*d;\n", nBitsOut, nBitsOut, 0 );
667 Vec_StrWriteEntry( vStr, Vec_StrSize(vStr) - i - 3, '1' );
668 }
669 Vec_StrPrintStr( vStr, " endcase\n" );
670 Vec_StrPrintStr( vStr, " endfunction\n" );
671 // assign z = res(i, o);
672 if ( Vec_BitEntry(vPoFons, iFonOut) )
673 Vec_StrPrintStr( vStr, " assign " );
674 else
675 {
676 Vec_StrPrintStr( vStr, " wire " );
677 Cba_ManWriteFonRange( p, iFonOut );
678 }
679 Cba_ManWriteFonName( p, iFonOut, fInlineConcat, 0 );
680 Vec_StrPrintStr( vStr, " = _func_" );
681 Cba_ManWriteFonName( p, iFonOut, 0, 0 );
682 Vec_StrPrintStr( vStr, " ( " );
683 Cba_ManWriteFonName( p, iFonIn, fInlineConcat, 0 );
684 Vec_StrPrintStr( vStr, " );" );
685 }
686 else if ( Type == CBA_BOX_DFFRS || Type == CBA_BOX_LATCHRS )
687 {
688 int fUseFlop = Type == CBA_BOX_DFFRS;
689 int iFonQ = Cba_ObjFon0(p, iObj);
690 int iFonD = Cba_ObjFinFon(p, iObj, 0);
691 int iFonSet = Cba_ObjFinFon(p, iObj, 1);
692 int iFonRst = Cba_ObjFinFon(p, iObj, 2);
693 int iFonC = Cba_ObjFinFon(p, iObj, 3);
694 int Range = Cba_FonRangeSize( p, iFonQ );
695 assert( Cba_FonRangeSize(p, iFonSet) == 1 && Cba_FonRangeSize(p, iFonRst) == 1 );
696 // reg [3:0] Q;
697 Vec_StrPrintStr( vStr, " reg " );
698 Cba_ManWriteFonRange( p, iFonQ );
699 Cba_ManWriteFonName( p, iFonQ, 0, 0 );
700 Vec_StrPrintStr( vStr, ";\n" );
701 // always @(posedge C or posedge PRE)
702 Vec_StrPrintStr( vStr, " always @(" );
703 if ( fUseFlop )
704 Vec_StrPrintStr( vStr, "posedge " );
705 Cba_ManWriteFonName( p, iFonC, 0, 0 );
706 if ( !fUseFlop )
707 {
708 Vec_StrPrintStr( vStr, " or " );
709 Cba_ManWriteFonName( p, iFonD, 0, 0 );
710 }
711 if ( iFonSet > 0 )
712 {
713 Vec_StrPrintStr( vStr, " or " );
714 if ( fUseFlop )
715 Vec_StrPrintStr( vStr, "posedge " );
716 Cba_ManWriteFonName( p, iFonSet, 0, 0 );
717 }
718 if ( iFonRst > 0 )
719 {
720 Vec_StrPrintStr( vStr, " or " );
721 if ( fUseFlop )
722 Vec_StrPrintStr( vStr, "posedge " );
723 Cba_ManWriteFonName( p, iFonRst, 0, 0 );
724 }
725 Vec_StrPrintStr( vStr, ")\n" );
726 // if (Set) Q <= 4'b1111;
727 if ( iFonSet > 0 )
728 {
729 Vec_StrPrintStr( vStr, " if (" );
730 Cba_ManWriteFonName( p, iFonSet, 0, 0 );
731 Vec_StrPrintStr( vStr, ") " );
732 Cba_ManWriteFonName( p, iFonQ, 0, 0 );
733 Vec_StrPrintStr( vStr, fUseFlop ? " <= " : " = " );
734 // value 1
735 Vec_StrPrintNum( vStr, Range );
736 Vec_StrPrintStr( vStr, "\'b" );
737 Vec_StrFillExtra( vStr, Vec_StrSize(vStr) + Range, '1' );
738 Vec_StrPrintStr( vStr, ";\n" );
739// Vec_StrPrintF( vStr, "\'b1" );
740 }
741 if ( iFonRst > 0 )
742 {
743 Vec_StrPrintStr( vStr, iFonSet > 0 ? " else if (" : " if (" );
744 Cba_ManWriteFonName( p, iFonRst, 0, 0 );
745 Vec_StrPrintStr( vStr, ") " );
746 Cba_ManWriteFonName( p, iFonQ, 0, 0 );
747 Vec_StrPrintStr( vStr, fUseFlop ? " <= " : " = " );
748 // value 0
749 Vec_StrPrintNum( vStr, Range );
750 Vec_StrPrintStr( vStr, "\'b" );
751 Vec_StrFillExtra( vStr, Vec_StrSize(vStr) + Range, '0' );
752 Vec_StrPrintStr( vStr, ";\n" );
753// Vec_StrPrintF( vStr, "\'b0" );
754 }
755 Vec_StrPrintStr( vStr, (iFonSet > 0 || iFonRst > 0) ? " else " : " " );
756 if ( !fUseFlop )
757 {
758 Vec_StrPrintStr( vStr, " if (" );
759 Cba_ManWriteFonName( p, iFonC, 0, 0 );
760 Vec_StrPrintStr( vStr, ") " );
761 }
762 Cba_ManWriteFonName( p, iFonQ, 0, 0 );
763 Vec_StrPrintStr( vStr, fUseFlop ? " <= " : " = " );
764 Cba_ManWriteFonName( p, iFonD, fInlineConcat, 0 );
765 Vec_StrPrintStr( vStr, ";" );
766 }
767 else if ( Type == CBA_BOX_DFFCPL )
768 {
769 // CPL_FF#32 inst_reg( .d(s1), .arstval(s2), .arst(s3), .clk(s4), .q(s5), .qbar(s6) );
770 int iFon0 = Cba_ObjFon0(p, iObj);
771 int iFon1 = Cba_ObjFon(p, iObj, 1);
772 int Range = Cba_FonRangeSize( p, iFon0 );
773 if ( !Vec_BitEntry(vPoFons, iFon0) )
774 {
775 Vec_StrPrintStr( vStr, " wire " );
776 Cba_ManWriteFonRange( p, iFon0 );
777 Cba_ManWriteFonName( p, iFon0, 0, 0 );
778 Vec_StrPrintStr( vStr, ";\n" );
779 }
780 if ( !Vec_BitEntry(vPoFons, iFon1) && Cba_FonName(p, iFon1) )
781 {
782 Vec_StrPrintStr( vStr, " wire " );
783 Cba_ManWriteFonRange( p, iFon1 );
784 Cba_ManWriteFonName( p, iFon1, 0, 0 );
785 Vec_StrPrintStr( vStr, ";\n" );
786 }
787 Vec_StrPrintStr( vStr, " CPL_FF" );
788 if ( Range > 1 )
789 Vec_StrPrintF( vStr, "#%d", Range );
790 Vec_StrPrintStr( vStr, " " );
791 if ( Cba_ObjName(p, iObj) )
792 Vec_StrPrintStr( vStr, Cba_ObjGetName(p, iObj) );
793 Vec_StrPrintStr( vStr, " ( .d(" );
794 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 0), fInlineConcat, 0 );
795 Vec_StrPrintStr( vStr, "), .arstval(" );
796 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 1), fInlineConcat, 0 );
797 Vec_StrPrintStr( vStr, "), .arst(" );
798 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 2), fInlineConcat, 0 );
799 Vec_StrPrintStr( vStr, "), .clk(" );
800 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 3), fInlineConcat, 0 );
801 Vec_StrPrintStr( vStr, "), .q(" );
802 Cba_ManWriteFonName( p, iFon0, fInlineConcat, 0 );
803 Vec_StrPrintStr( vStr, "), .qbar(" );
804 if ( Cba_FonName(p, iFon1) )
805 Cba_ManWriteFonName( p, iFon1, fInlineConcat, 0 );
806 Vec_StrPrintStr( vStr, ") );" );
807 }
808 else if ( Type == CBA_BOX_ADD )
809 {
810 int iFon0 = Cba_ObjFon0(p, iObj);
811 int iFon1 = Cba_ObjFon(p, iObj, 1);
812 // write outputs
813 if ( Cba_FonName(p, iFon1) )
814 {
815 if ( !Vec_BitEntry(vPoFons, iFon0) )
816 {
817 Vec_StrPrintStr( vStr, " wire " );
818 Cba_ManWriteFonRange( p, iFon0 );
819 Cba_ManWriteFonName( p, iFon0, 0, 0 );
820 Vec_StrPrintStr( vStr, ";\n" );
821 }
822 if ( !Vec_BitEntry(vPoFons, iFon1) )
823 {
824 Vec_StrPrintStr( vStr, " wire " );
825 Cba_ManWriteFonRange( p, iFon1 );
826 Cba_ManWriteFonName( p, iFon1, 0, 0 );
827 Vec_StrPrintStr( vStr, ";\n" );
828 }
829 Vec_StrPrintStr( vStr, " assign {" );
830 Cba_ManWriteFonName( p, iFon1, 0, 0 );
831 Vec_StrPrintStr( vStr, ", " );
832 Cba_ManWriteFonName( p, iFon0, 0, 0 );
833 Vec_StrPrintStr( vStr, "} = " );
834 }
835 else
836 {
837 if ( Vec_BitEntry(vPoFons, iFon0) )
838 Vec_StrPrintStr( vStr, " assign " );
839 else
840 {
841 Vec_StrPrintStr( vStr, " wire " );
842 Cba_ManWriteFonRange( p, iFon0 );
843 }
844 Cba_ManWriteFonName( p, iFon0, 0, 0 );
845 Vec_StrPrintStr( vStr, " = " );
846 }
847 // write carry-in
848 if ( Cba_ObjFinFon(p, iObj, 0) && Cba_ObjFinFon(p, iObj, 0) != Cba_FonFromConst(1) )
849 {
850 Vec_StrPush( vStr, ' ' );
851 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 0), fInlineConcat, 0 );
852 Vec_StrPush( vStr, ' ' );
853 Vec_StrPrintStr( vStr, "+" );
854 }
855 Vec_StrPush( vStr, ' ' );
856 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 1), fInlineConcat, 0 );
857 Vec_StrPush( vStr, ' ' );
858 Vec_StrPrintStr( vStr, "+" );
859 Vec_StrPush( vStr, ' ' );
860 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 2), fInlineConcat, 0 );
861 Vec_StrPush( vStr, ';' );
862 }
863 else
864 {
865 if ( Vec_BitEntry(vPoFons, Cba_ObjFon0(p, iObj)) )
866 Vec_StrPrintStr( vStr, " assign " );
867 else
868 {
869 Vec_StrPrintStr( vStr, " wire " );
870 Cba_ManWriteFonRange( p, Cba_ObjFon0(p, iObj) );
871 }
872 Cba_ManWriteFonName( p, Cba_ObjFon0(p, iObj), 0, 0 );
873 Vec_StrPrintStr( vStr, " = " );
874 if ( Cba_ObjIsConcat(p, iObj) )
875 Cba_ManWriteConcat( p, iObj );
876 else if ( Type == CBA_BOX_MUX )
877 {
878 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 0), fInlineConcat, 0 );
879 Vec_StrPrintStr( vStr, " ? " );
880 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 1), fInlineConcat, 0 );
881 Vec_StrPrintStr( vStr, " : " );
882 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 2), fInlineConcat, 0 );
883 }
884 else if ( Type == CBA_BOX_ROTL || Type == CBA_BOX_ROTR )
885 {
886 // wire [27:0] s4960 = (s57 >> 17) | (s57 << 11);
887 int Range = Cba_FonRangeSize( p, Cba_ObjFon0(p, iObj) );
888 int iFinFon1 = Cba_ObjFinFon(p, iObj, 1);
889 Vec_StrPush( vStr, '(' );
890 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 0), fInlineConcat, 0 );
891 Vec_StrPrintStr( vStr, Type == CBA_BOX_ROTL ? " << " : " >> " );
892 if ( Cba_FonIsConst(iFinFon1) )
893 Vec_StrPrintNum( vStr, Cba_FonConst(iFinFon1) );
894 else
895 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 1), fInlineConcat, 0 );
896 Vec_StrPrintStr( vStr, ") | (" );
897 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 0), fInlineConcat, 0 );
898 Vec_StrPrintStr( vStr, Type == CBA_BOX_ROTL ? " >> " : " << " );
899 if ( Cba_FonIsConst(iFinFon1) )
900 Vec_StrPrintNum( vStr, Range - Cba_FonConst(iFinFon1) );
901 else
902 {
903 Vec_StrPush( vStr, '(' );
904 Vec_StrPrintNum( vStr, Range );
905 Vec_StrPrintStr( vStr, " - " );
906 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 1), fInlineConcat, 0 );
907 Vec_StrPush( vStr, ')' );
908 }
909 Vec_StrPush( vStr, ')' );
910 }
911 else if ( Type == CBA_BOX_LTHAN )
912 {
913 int fLessThan = (Cba_ObjFinFon(p, iObj, 0) == Cba_FonFromConst(1)); // const0
914 Vec_StrPush( vStr, ' ' );
915 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 1), fInlineConcat, 0 );
916 Vec_StrPush( vStr, ' ' );
917 Vec_StrPrintStr( vStr, fLessThan ? "<" : "<=" );
918 Vec_StrPush( vStr, ' ' );
919 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 2), fInlineConcat, 0 );
920 }
921 else if ( Cba_TypeIsUnary((Cba_ObjType_t)Type) )
922 {
923 Vec_StrPrintStr( vStr, Cba_NtkTypeName(p, Type) );
924 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 0), fInlineConcat, 0 );
925 }
926 else if ( Cba_NtkTypeName(p, Type) ) // binary operation
927 {
928 int fCompl = (Type == CBA_BOX_NAND || Type == CBA_BOX_NOR || Type == CBA_BOX_XNOR);
929 if ( fCompl )
930 Vec_StrPrintStr( vStr, "!(" );
931 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 0), fInlineConcat, 0 );
932 Vec_StrPush( vStr, ' ' );
933 Vec_StrPrintStr( vStr, Cba_NtkTypeName(p, Type) );
934 Vec_StrPush( vStr, ' ' );
935 Cba_ManWriteFonName( p, Cba_ObjFinFon(p, iObj, 1), fInlineConcat, 0 );
936 if ( fCompl )
937 Vec_StrPrintStr( vStr, ")" );
938 }
939 else // unknown
940 {
941 char * pName = Cba_FonGetName(p, Cba_ObjFon0(p, iObj));
942 Vec_StrPrintStr( vStr, "<unknown operator>" );
943 printf( "Cba_ManWriteVerilog(): In module \"%s\", cannot write object \"%s\" with output name \"%s\".\n", Cba_NtkName(p), Cba_ObjGetName(p, iObj), pName );
944 }
945 Vec_StrPush( vStr, ';' );
946 }
947 // write attributes
948 Status = Cba_ManWriteLineFile( p, iObj, FileAttr, LineAttr );
949 if ( !Cba_ObjIsBoxUser(p, iObj) && Cba_ObjName(p, iObj) )
950 {
951 if ( !Status )
952 Vec_StrPrintStr( vStr, " //" );
953 Vec_StrPrintStr( vStr, " name=" );
954 Vec_StrPrintStr( vStr, Cba_ObjGetName(p, iObj) );
955 }
956 Vec_StrPush( vStr, '\n' );
957 }
958 // write remaining outputs
959 Cba_NtkForEachPo( p, iObj, i )
960 {
961 iFon = Cba_ObjFinFon(p, iObj, 0);
962 if ( !iFon || (!Cba_FonIsConst(iFon) && Cba_FonName(p, iFon) == Cba_ObjName(p, iObj)) ) // already written
963 continue;
964 Vec_StrPrintStr( vStr, " assign " );
965 Vec_StrPrintStr( vStr, Cba_ObjGetName(p, iObj) );
966 Vec_StrPrintStr( vStr, " = " );
967 Cba_ManWriteFonName( p, iFon, fInlineConcat, 0 );
968 Vec_StrPush( vStr, ';' );
969 Vec_StrPush( vStr, '\n' );
970 }
971 Vec_StrPrintStr( vStr, "\n" );
972 Vec_StrPrintStr( vStr, "endmodule\n\n" );
973 Vec_BitFree( vPoFons );
974}
Cba_ObjType_t
Cba_ObjType_t
INCLUDES ///.
Definition cbaTypes.h:39
CBA_BOX_DFFCPL
@ CBA_BOX_DFFCPL
Definition cbaTypes.h:138
Cba_ManWriteFonRange
void Cba_ManWriteFonRange(Cba_Ntk_t *p, int iFon)
Definition cbaWriteVer.c:398
Cba_ObjGetName
char * Cba_ObjGetName(Cba_Ntk_t *p, int i)
Definition cbaWriteVer.c:361
Cba_ManWriteLineFile
int Cba_ManWriteLineFile(Cba_Ntk_t *p, int iObj, int FileAttr, int LineAttr)
Definition cbaWriteVer.c:439
Cba_NtkForEachPioOrder
#define Cba_NtkForEachPioOrder(p, iObj, i)
Definition cba.h:314
Cba_NtkForEachBox
#define Cba_NtkForEachBox(p, i)
Definition cba.h:328
Cba_NtkForEachPo
#define Cba_NtkForEachPo(p, iObj, i)
Definition cba.h:310
Cba_ObjForEachFon
#define Cba_ObjForEachFon(p, iObj, iFon, k)
Definition cba.h:346
Cba_NtkForEachPoDriverFon
#define Cba_NtkForEachPoDriverFon(p, iObj, iFon, i)
Definition cba.h:319
Vec_Bit_t
typedefABC_NAMESPACE_HEADER_START struct Vec_Bit_t_ Vec_Bit_t
INCLUDES ///.
Definition vecBit.h:42
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Cba_ObjGetName()

char * Cba_ObjGetName ( Cba_Ntk_t * p,
int i )

Definition at line 361 of file cbaWriteVer.c.

362{
363 char * pName = Cba_ObjNameStr(p, i);
364 if ( pName == NULL )
365 return pName;
366 if ( Cba_NameIsLegalInVerilog(pName, Cba_ObjName(p, i)) )
367 return pName;
368 return Vec_StrPrintF( Abc_NamBuffer(Cba_NtkNam(p)), "\\%s ", pName );
369}
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Prs_ManWriteVerilog()

void Prs_ManWriteVerilog ( char * pFileName,
Vec_Ptr_t * vPrs )

Definition at line 322 of file cbaWriteVer.c.

323{
324 char * pTypeNames[CBA_BOX_LAST];
325 Prs_Ntk_t * pNtk = Prs_ManRoot(vPrs); int i;
326 FILE * pFile = fopen( pFileName, "wb" );
327 if ( pFile == NULL )
328 {
329 printf( "Cannot open output file \"%s\".\n", pFileName );
330 return;
331 }
332 Cba_ManCreatePrimMap( pTypeNames );
333 fprintf( pFile, "// Design \"%s\" written by ABC on %s\n\n", Prs_NtkStr(pNtk, pNtk->iModuleName), Extra_TimeStamp() );
334 Vec_PtrForEachEntry( Prs_Ntk_t *, vPrs, pNtk, i )
335 Prs_ManWriteVerilogNtk( pFile, pNtk, pTypeNames );
336 fclose( pFile );
337}
Prs_Ntk_t
struct Prs_Ntk_t_ Prs_Ntk_t
BASIC TYPES ///.
Definition cbaPrs.h:73
Prs_Ntk_t_::iModuleName
int iModuleName
Definition cbaPrs.h:77
Vec_PtrForEachEntry
#define Vec_PtrForEachEntry(Type, vVec, pEntry, i)
MACRO DEFINITIONS ///.
Definition vecPtr.h:55
Here is the call graph for this function:
Here is the caller graph for this function:

◆ Prs_ManWriteVerilogArray()

void Prs_ManWriteVerilogArray ( FILE * pFile,
Prs_Ntk_t * p,
Vec_Int_t * vSigs,
int fOdd )

Definition at line 191 of file cbaWriteVer.c.

192{
193 int i, Sig, fFirst = 1;
194 assert( Vec_IntSize(vSigs) > 0 );
195 Vec_IntForEachEntry( vSigs, Sig, i )
196 {
197 if ( fOdd && !(i & 1) )
198 continue;
199 fprintf( pFile, "%s", fFirst ? "" : ", " );
200 Prs_ManWriteVerilogSignal( pFile, p, Sig );
201 fFirst = 0;
202 }
203}
Vec_IntForEachEntry
#define Vec_IntForEachEntry(vVec, Entry, i)
MACRO DEFINITIONS ///.
Definition vecInt.h:54

◆ Prs_ObjGetName()

char * Prs_ObjGetName ( Prs_Ntk_t * p,
int NameId )

Definition at line 151 of file cbaWriteVer.c.

152{
153 char * pName = Prs_NtkStr(p, NameId);
154 if ( pName == NULL )
155 return pName;
156 if ( Prs_NameIsLegalInVerilog(pName, NameId) )
157 return pName;
158 return Vec_StrPrintF( Abc_NamBuffer(p->pStrs), "\\%s ", pName );
159}
Here is the call graph for this function: