cbaReadVer.c File Reference

#include "cba.h"
#include "cbaPrs.h"

Include dependency graph for cbaReadVer.c:

Go to the source code of this file.

Classes
struct	Prs_VerPrim_t_
struct	Prs_VerInfo_t_

Typedefs
typedef struct Prs_VerPrim_t_	Prs_VerPrim_t
	FUNCTION DEFINITIONS ///.
typedef struct Prs_VerInfo_t_	Prs_VerInfo_t

Functions
void	Prs_NtkAddVerilogDirectives (Prs_Man_t *p)
	ITERATORS ///.
int	Prs_ManReadSignalList (Prs_Man_t *p, Vec_Int_t *vTemp, char LastSymb, int fAddForm)
void	Prs_ManPrintModules (Prs_Man_t *p)
Vec_Ptr_t *	Prs_ManReadVerilog (char *pFileName)
void	Prs_ManReadVerilogTest (char *pFileName)
int	Prs_CreateVerilogFindFon (Cba_Ntk_t *p, int NameId)
int	Prs_CreateSlice (Cba_Ntk_t *p, int iFon, Prs_Ntk_t *pNtk, int Range)
int	Prs_CreateCatIn (Cba_Ntk_t *p, Prs_Ntk_t *pNtk, int Con)
int	Prs_CreateSignalIn (Cba_Ntk_t *p, Prs_Ntk_t *pNtk, int Sig)
int	Prs_CreateRange (Cba_Ntk_t *p, int iFon, int NameId)
void	Prs_CreateSignalOut (Cba_Ntk_t *p, int iFon, Prs_Ntk_t *pNtk, int Sig)
void	Prs_CreateOutConcat (Cba_Ntk_t *p, int *pSlices, int nSlices)
int	Prs_CreateBitSignal (Prs_Ntk_t *pNtk, int Sig)
int	Prs_CreateFlopSetReset (Cba_Ntk_t *p, Prs_Ntk_t *pNtk, Vec_Int_t *vBox, int *pIndexSet, int *pIndexRst, int *pBitSet, int *pBitRst)
char *	Prs_CreateDetectRamPort (Prs_Ntk_t *pNtk, Vec_Int_t *vBox, int NameRamId)
int	Prs_CreateGetMemSize (char *pName)
Vec_Ptr_t *	Prs_CreateDetectRams (Prs_Ntk_t *pNtk)
void	Prs_CreateVerilogPio (Cba_Ntk_t *p, Prs_Ntk_t *pNtk)
int	Prs_CreateVerilogNtk (Cba_Ntk_t *p, Prs_Ntk_t *pNtk)
Cba_Man_t *	Prs_ManBuildCbaVerilog (char *pFileName, Vec_Ptr_t *vDes)
Cba_Man_t *	Cba_ManReadVerilog (char *pFileName)

Typedef Documentation

Prs_VerInfo_t

typedef struct Prs_VerInfo_t_ Prs_VerInfo_t

Definition at line 171 of file cbaReadVer.c.

Prs_VerPrim_t

typedef struct Prs_VerPrim_t_ Prs_VerPrim_t

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 90 of file cbaReadVer.c.

Function Documentation

Cba_ManReadVerilog()

Cba_Man_t * Cba_ManReadVerilog

(

char *

pFileName

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 2165 of file cbaReadVer.c.

{
    Cba_Man_t * p = NULL;
    Vec_Ptr_t * vDes = Prs_ManReadVerilog( pFileName );
    if ( vDes && Vec_PtrSize(vDes) )
        p = Prs_ManBuildCbaVerilog( pFileName, vDes );
    if ( vDes )
        Prs_ManVecFree( vDes );
    return p;
}

Here is the call graph for this function:

Prs_CreateBitSignal()

int Prs_CreateBitSignal	(	Prs_Ntk_t *	pNtk,
		int	Sig )

Definition at line 1645 of file cbaReadVer.c.

{
    Vec_Int_t * vSigs;
    int i, SigTemp, SigOne = -1, Value = Abc_Lit2Var2( Sig );
    Prs_ManType_t Type = (Prs_ManType_t)Abc_Lit2Att2( Sig );
    if ( Type == CBA_PRS_NAME || Type == CBA_PRS_SLICE )
        return -1;
    if ( Type == CBA_PRS_CONST )
    {
        int fOnly0 = 1, fOnly1 = 1;
        char * pConst = Prs_NtkConst(pNtk, Value);
        pConst = strchr( pConst, '\'' ) + 1;
        assert( *pConst == 'b' );
        while ( *++pConst )
            if ( *pConst == '0' )
                fOnly1 = 0;
            else if ( *pConst == '1' )
                fOnly0 = 0;
        if ( fOnly0 )
            return Abc_Var2Lit2( 1, CBA_PRS_CONST ); // const0
        if ( fOnly1 )
            return Abc_Var2Lit2( 2, CBA_PRS_CONST ); // const1
        return -1;
    }
    assert( Type == CBA_PRS_CONCAT );
    vSigs = Prs_CatSignals( pNtk, Value );
    Vec_IntForEachEntry( vSigs, SigTemp, i )
    {
        Value = Abc_Lit2Var2( SigTemp );
        Type = (Prs_ManType_t)Abc_Lit2Att2( SigTemp );
        if ( Type != CBA_PRS_NAME )
            return -1;
        if ( SigOne == -1 )
            SigOne = Value;
        else if ( SigOne != Value )
            return -1;
    }
    assert( SigOne >= 0 );
    return Abc_Var2Lit2( SigOne, CBA_PRS_NAME );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Prs_CreateCatIn()

int Prs_CreateCatIn	(	Cba_Ntk_t *	p,
		Prs_Ntk_t *	pNtk,
		int	Con )

Definition at line 1446 of file cbaReadVer.c.

{
    extern int Prs_CreateSignalIn( Cba_Ntk_t * p, Prs_Ntk_t * pNtk, int Sig );
    int i, Sig, iObj, iFon, NameId, nBits = 0;
    Vec_Int_t * vSigs = Prs_CatSignals(pNtk, Con);
    // create input concatenation
    iObj = Cba_ObjAlloc( p, CBA_BOX_CONCAT, Vec_IntSize(vSigs), 1 );
    iFon = Cba_ObjFon0(p, iObj);
    //sprintf( Buffer, "_icc%d_", iObj );
    //NameId = Cba_NtkNewStrId( p, Buffer );
    NameId = Cba_NtkNewStrId( p, "_icc%d_", iObj );
    Cba_FonSetName( p, iFon, NameId );
    Cba_NtkSetMap( p, NameId, iFon );
    // set inputs
    Vec_IntForEachEntry( vSigs, Sig, i )
    {
        iFon = Prs_CreateSignalIn( p, pNtk, Sig );
        if ( iFon )
            Cba_ObjSetFinFon( p, iObj, i, iFon );
        if ( iFon )
            nBits += Cba_FonRangeSize( p, iFon );
    }
    iFon = Cba_ObjFon0(p, iObj);
    Cba_FonSetRange( p, iFon, Cba_NtkHashRange(p, nBits-1, 0) );
    return Cba_ObjFon0(p, iObj);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Prs_CreateDetectRamPort()

char * Prs_CreateDetectRamPort	(	Prs_Ntk_t *	pNtk,
		Vec_Int_t *	vBox,
		int	NameRamId )

Definition at line 1718 of file cbaReadVer.c.

{
    int i, FormId, ActId;
    Vec_IntForEachEntryDouble( vBox, FormId, ActId, i )
        if ( FormId == NameRamId )
            return Abc_NamStr(pNtk->pStrs, Abc_Lit2Var2(ActId));
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Prs_CreateDetectRams()

Vec_Ptr_t * Prs_CreateDetectRams

(

Prs_Ntk_t *

pNtk

)

Definition at line 1735 of file cbaReadVer.c.

{
    Vec_Ptr_t * vAllRams = NULL, * vRam; 
    Vec_Int_t * vBox, * vBoxCopy; 
    char * pNtkName, * pRamName;
    int NameRamId = Abc_NamStrFind( pNtk->pStrs, "Ram" );
    int i, k, fWrite;
    Prs_NtkForEachBox( pNtk, vBox, i )
    {
        if ( Prs_BoxIsNode(pNtk, i) ) // node
            continue;
        pNtkName = Prs_NtkStr(pNtk, Prs_BoxNtk(pNtk, i));
        fWrite = !strncmp(pNtkName, "ClockedWritePort_", strlen("ClockedWritePort_"));
        if ( fWrite || !strncmp(pNtkName, "ReadPort_", strlen("ReadPort_")) )
        {
            pRamName = Prs_CreateDetectRamPort( pNtk, vBox, NameRamId ); assert( pRamName );
            if ( vAllRams == NULL )
                vAllRams = Vec_PtrAlloc( 4 );
            Vec_PtrForEachEntry( Vec_Ptr_t *, vAllRams, vRam, k )
                if ( pRamName == (char *)Vec_PtrEntry(vRam, 0) )
                {
                    if ( fWrite )
                    {
                        vBoxCopy = Vec_IntDup(vBox);
                        Vec_IntPush( vBoxCopy, i );
                        Vec_PtrPush( vRam, vBoxCopy );
                    }
                    break;
                }
            if ( k < Vec_PtrSize(vAllRams) )
                continue;
            vRam = Vec_PtrAlloc( 4 );
            Vec_PtrPush( vRam, pRamName );
            Vec_PtrPush( vRam, Abc_Int2Ptr(Prs_CreateGetMemSize(pNtkName)) );
            if ( fWrite )
            {
                vBoxCopy = Vec_IntDup(vBox);
                Vec_IntPush( vBoxCopy, i );
                Vec_PtrPush( vRam, vBoxCopy );
            }
            Vec_PtrPush( vAllRams, vRam );
        }
    }
    return vAllRams;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Prs_CreateFlopSetReset()

int Prs_CreateFlopSetReset	(	Cba_Ntk_t *	p,
		Prs_Ntk_t *	pNtk,
		Vec_Int_t *	vBox,
		int *	pIndexSet,
		int *	pIndexRst,
		int *	pBitSet,
		int *	pBitRst )

Definition at line 1686 of file cbaReadVer.c.

{
    int iSigSet = -1, iSigRst = -1;
    int IndexSet = -1, IndexRst = -1;
    int FormId, ActId, k;
    // mark set and reset
    Cba_NtkCleanMap2( p );
    Cba_NtkSetMap2( p, Cba_NtkStrId(p, "set"), 1 );
    Cba_NtkSetMap2( p, Cba_NtkStrId(p, "reset"), 2 );
    // check the inputs
    Vec_IntForEachEntryDouble( vBox, FormId, ActId, k )
        if ( Cba_NtkGetMap2(p, FormId) == 1 ) // set
            iSigSet = ActId, IndexSet = k+1;
        else if ( Cba_NtkGetMap2(p, FormId) == 2 ) // reset
            iSigRst = ActId, IndexRst = k+1;
    assert( iSigSet >= 0 && iSigRst >= 0 );
    if ( pIndexSet ) *pBitSet = 0;
    if ( pIndexRst ) *pBitRst = 0;
    if ( pBitSet )   *pBitSet = 0;
    if ( pBitRst )   *pBitRst = 0;
    if ( iSigSet == -1 || iSigRst == -1 )
        return 0;
    iSigSet = Prs_CreateBitSignal(pNtk, iSigSet);
    iSigRst = Prs_CreateBitSignal(pNtk, iSigRst);
    if ( iSigSet == -1 || iSigRst == -1 )
        return 0;
    if ( pIndexSet ) *pIndexSet = IndexSet;
    if ( pIndexRst ) *pIndexRst = IndexRst;
    if ( pBitSet )   *pBitSet = iSigSet;
    if ( pBitRst )   *pBitRst = iSigRst;
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Prs_CreateGetMemSize()

int Prs_CreateGetMemSize

(

char *

pName

)

Definition at line 1726 of file cbaReadVer.c.

{
    char * pPtr1 = strchr( pName, '_' );
    char * pPtr2 = strchr( pPtr1+1, '_' );
    int Num1 = atoi( pPtr1 + 1 );
    int Num2 = atoi( pPtr2 + 1 );
    assert( Num1 + Abc_Base2Log(Num2) < 32 );
    return (1 << Num1) * Num2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Prs_CreateOutConcat()

void Prs_CreateOutConcat	(	Cba_Ntk_t *	p,
		int *	pSlices,
		int	nSlices )

Definition at line 1581 of file cbaReadVer.c.

{
    Vec_Int_t * vBits = &p->vArray1;
    int NameId    = pSlices[0];
    int RangeId   = -Cba_NtkGetMap(p, NameId);
    int LeftId    = Cba_NtkRangeLeft( p, RangeId );
    int RightId   = Cba_NtkRangeRight( p, RangeId );
    int BotId     = Abc_MinInt( LeftId, RightId );
    int TopId     = Abc_MaxInt( LeftId, RightId );
    int i, k, iObj, iFon, nParts, Prev, nBits;
    assert( RangeId > 0 );
    Vec_IntFill( vBits, Abc_MaxInt(LeftId, RightId) + 1, 0 );
    // fill up with slices
    for ( i = 0; i < nSlices; i++ )
    {
        int Range = pSlices[3*i+1];
        int iFon  = pSlices[3*i+2];
        int Left  = Cba_NtkRangeLeft( p, Range );
        int Right = Cba_NtkRangeRight( p, Range );
        int Bot   = Abc_MinInt( Left, Right );
        int Top   = Abc_MaxInt( Left, Right );
        assert( NameId == pSlices[3*i+0] && iFon > 0 );
        assert( BotId <= Bot && Top <= TopId );
        for ( k = Bot; k <= Top; k++ )
        {
            assert( Vec_IntEntry(vBits, k) == 0 );
            Vec_IntWriteEntry( vBits, k, iFon );
        }
    }
    // check how many parts we have
    Prev = -1; nParts = 0; 
    Vec_IntForEachEntryStartStop( vBits, iFon, i, BotId, TopId+1 )
    {
        if ( Prev != iFon )
            nParts++;
        Prev = iFon;
    }
    // create new concatenation
    iObj = Cba_ObjAlloc( p, CBA_BOX_CONCAT, nParts, 1 );
    iFon = Cba_ObjFon0(p, iObj);
    Cba_FonSetName( p, iFon, NameId );
    Prs_CreateRange( p, iFon, NameId );
    // set inputs
    k = 0; Prev = -1; nBits = 0;
    Vec_IntForEachEntryStartStop( vBits, iFon, i, BotId, TopId+1 )
    {
        if ( Prev == -1 || Prev == iFon )
            nBits++;
        else
        {
            if ( Prev == 0 ) // create constant
                Prev = Cba_ManNewConstZero( p, nBits );
            assert( nBits == Cba_FonRangeSize(p, Prev) );
            Cba_ObjSetFinFon( p, iObj, nParts-1-k++, Prev );
            nBits = 1;
        }
        Prev = iFon;         
    }
    assert( nBits == Cba_FonRangeSize(p, Prev) );
    Cba_ObjSetFinFon( p, iObj, nParts-1-k++, Prev );
    assert( k == nParts );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Prs_CreateRange()

int Prs_CreateRange	(	Cba_Ntk_t *	p,
		int	iFon,
		int	NameId )

Definition at line 1491 of file cbaReadVer.c.

{
    int RangeId = -Cba_NtkGetMap(p, NameId);
    if ( RangeId < 0 ) // this variable is already created
        return Cba_FonRangeSize( p, -RangeId );
    Cba_NtkUnsetMap( p, NameId );
    Cba_NtkSetMap( p, NameId, iFon );
    if ( RangeId == 0 )
        return 1;
    assert( RangeId > 0 );
    Cba_FonSetRangeSign( p, iFon, RangeId );
    return Cba_FonRangeSize( p, iFon );
}

Here is the caller graph for this function:

Prs_CreateSignalIn()

int Prs_CreateSignalIn	(	Cba_Ntk_t *	p,
		Prs_Ntk_t *	pNtk,
		int	Sig )

Definition at line 1472 of file cbaReadVer.c.

{
    int iFon, Value = Abc_Lit2Var2( Sig );
    Prs_ManType_t Type = (Prs_ManType_t)Abc_Lit2Att2( Sig );
    if ( !Sig ) return 0;
    if ( Type == CBA_PRS_NAME )
        return Prs_CreateVerilogFindFon( p, Cba_NtkNewStrId(p, Prs_NtkStr(pNtk, Value)) );
    if ( Type == CBA_PRS_CONST )
        return Cba_FonFromConst( Value );
    if ( Type == CBA_PRS_SLICE )
    {
        iFon =  Prs_CreateVerilogFindFon( p, Cba_NtkNewStrId(p, Prs_NtkStr(pNtk, Prs_SliceName(pNtk, Value))) );
        if ( !iFon )
            return 0;
        return Prs_CreateSlice( p, iFon, pNtk, Prs_SliceRange(pNtk, Value) );
    }
    assert( Type == CBA_PRS_CONCAT );
    return Prs_CreateCatIn( p, pNtk, Value );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Prs_CreateSignalOut()

void Prs_CreateSignalOut	(	Cba_Ntk_t *	p,
		int	iFon,
		Prs_Ntk_t *	pNtk,
		int	Sig )

Definition at line 1504 of file cbaReadVer.c.

{
    int i, iFonNew, NameOut, RangeOut, NameId, RangeId, RangeSize, nBits = 0; 
    Prs_ManType_t SigType = (Prs_ManType_t)Abc_Lit2Att2( Sig );
    int SigValue = Abc_Lit2Var2( Sig );
    if ( !Sig ) return;
    if ( SigType == CBA_PRS_NAME )
    {
        NameId = SigValue;
        if ( !strncmp(Cba_NtkStr(p, NameId), "Open_", 5) )
            return;
        Cba_FonSetName( p, iFon, NameId );
        Prs_CreateRange( p, iFon, NameId );
        return;
    }
    // create name for this fan
    NameOut = Cba_NtkNewStrId( p, "_occ%d_", iFon );
    Cba_FonSetName( p, iFon, NameOut );
    Cba_NtkSetMap( p, NameOut, iFon );
    // consider special cases
    if ( SigType == CBA_PRS_SLICE )
    {
        NameId  = Prs_SliceName(pNtk, SigValue);
        RangeId = Prs_SliceRange(pNtk, SigValue);
        nBits   = Cba_NtkRangeSize(p, RangeId);
        // save this slice
        Vec_IntPushThree( &p->vArray0, NameId, RangeId, iFon );
    }
    else if ( SigType == CBA_PRS_CONCAT )
    {
        Vec_Int_t * vSigs = Prs_CatSignals(pNtk, SigValue);
        Vec_IntReverseOrder( vSigs );
        Vec_IntForEachEntry( vSigs, Sig, i )
        {
            SigType = (Prs_ManType_t)Abc_Lit2Att2( Sig );
            SigValue = Abc_Lit2Var2( Sig );
            if ( SigType == CBA_PRS_NAME )
            {
                int iObjBuf, iFonBuf;
                // create buffer
                NameId = SigValue;
                if ( !strncmp(Cba_NtkStr(p, NameId), "Open_", 5) )
                {
                    nBits++;
                    continue;
                }
                iObjBuf   = Cba_ObjAlloc( p, CBA_BOX_BUF, 1, 1 );
                iFonBuf   = Cba_ObjFon0(p, iObjBuf);
                Cba_FonSetName( p, iFonBuf, NameId );
                RangeSize = Prs_CreateRange( p, iFonBuf, NameId );
                RangeOut  = Cba_NtkHashRange(p, nBits+RangeSize-1, nBits);
                // create slice
                iFonNew   = Prs_CreateSlice( p, iFon, pNtk, RangeOut );
                Cba_ObjSetFinFon( p, iObjBuf, 0, iFonNew );
            }
            else if ( SigType == CBA_PRS_SLICE )
            {
                NameId    = Prs_SliceName(pNtk, SigValue);
                RangeId   = Prs_SliceRange(pNtk, SigValue);
                RangeSize = Cba_NtkRangeSize(p, RangeId);
                RangeOut  = Cba_NtkHashRange(p, nBits+RangeSize-1, nBits);
                // create slice
                iFonNew   = Prs_CreateSlice( p, iFon, pNtk, RangeOut );
                // save this slice
                Vec_IntPushThree( &p->vArray0, NameId, RangeId, iFonNew );
            }
            else assert( 0 );
            // increment complete range
            nBits += RangeSize;
        }
        Vec_IntReverseOrder( vSigs );
    }
    else assert( 0 );
    // set the range for the output
    Cba_FonHashRange( p, iFon, nBits-1, 0 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Prs_CreateSlice()

int Prs_CreateSlice	(	Cba_Ntk_t *	p,
		int	iFon,
		Prs_Ntk_t *	pNtk,
		int	Range )

Definition at line 1427 of file cbaReadVer.c.

{
    int iObj, iFonNew, NameId;
    assert( Cba_FonIsReal(iFon) );
    // check existing slice
    NameId = Cba_NtkNewStrId( p, Cba_ManGetSliceName(p, iFon, Range) );
    iFonNew = Cba_NtkGetMap( p, NameId );
    if ( iFonNew )
        return iFonNew;
    // create slice
    iObj = Cba_ObjAlloc( p, CBA_BOX_SLICE, 1, 1 );
    Cba_ObjSetName( p, iObj, NameId );
    Cba_ObjSetFinFon( p, iObj, 0, iFon );
    iFonNew = Cba_ObjFon0(p, iObj);
    Cba_FonSetRange( p, iFonNew, Range );
    Cba_FonSetName( p, iFonNew, NameId );
    Cba_NtkSetMap( p, NameId, iFonNew );
    return iFonNew;        
}

Here is the call graph for this function:

Here is the caller graph for this function:

Prs_CreateVerilogFindFon()

int Prs_CreateVerilogFindFon	(	Cba_Ntk_t *	p,
		int	NameId )

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1419 of file cbaReadVer.c.

{
    int iFon = Cba_NtkGetMap( p, NameId );
    if ( iFon )
        return iFon;
    printf( "Network \"%s\": Signal \"%s\" is not driven.\n", Cba_NtkName(p), Cba_NtkStr(p, NameId) );
    return 0;
}

Here is the caller graph for this function:

Prs_CreateVerilogNtk()

int Prs_CreateVerilogNtk	(	Cba_Ntk_t *	p,
		Prs_Ntk_t *	pNtk )

Definition at line 1814 of file cbaReadVer.c.

{
    Vec_Int_t * vBox2Obj = Vec_IntStart( Prs_NtkBoxNum(pNtk) );
    Vec_Int_t * vBox;  Vec_Ptr_t * vAllRams, * vRam;
    int i, k, iObj, iTerm, iFon, FormId, ActId, RangeId, NameId, Type;
    // map inputs
    Cba_NtkCleanMap( p );
    Cba_NtkForEachPi( p, iObj, i )
        Cba_NtkSetMap( p, Cba_ObjName(p, iObj), Cba_ObjFon0(p, iObj) );
 
    // map wire names into their rangeID
    Vec_IntForEachEntryTwo( &pNtk->vWires, &pNtk->vWiresR, NameId, RangeId, i )
        Cba_NtkSetMap( p, NameId, -RangeId );
    Vec_IntForEachEntryTwo( &pNtk->vOutputs, &pNtk->vOutputsR, NameId, RangeId, i )
        Cba_NtkSetMap( p, NameId, -RangeId );
 
    // collect RAMs and create boxes
    vAllRams = Prs_CreateDetectRams( pNtk );
    if ( vAllRams )
    Vec_PtrForEachEntry( Vec_Ptr_t *, vAllRams, vRam, i )
    {
        char * pRamName = (char *)Vec_PtrEntry( vRam, 0 );
        int MemSize = Abc_Ptr2Int( (char *)Vec_PtrEntry( vRam, 1 ) );
        //char Buffer[1000]; sprintf( Buffer, "%s_box", pRamName );
        //NameId = Cba_NtkNewStrId( p, Buffer ); 
        NameId = Cba_NtkNewStrId( p, "%s_box", pRamName );
        // create RAM object
        iObj = Cba_ObjAlloc( p, CBA_BOX_RAMBOX, Vec_PtrSize(vRam)-2, 1 );
        Cba_ObjSetName( p, iObj, NameId );
        iFon = Cba_ObjFon0(p, iObj);
        NameId = Cba_NtkNewStrId( p, pRamName ); 
        Cba_FonSetName( p, iFon, NameId );
        Prs_CreateRange( p, iFon, NameId );
        assert( Cba_FonLeft(p, iFon) <= MemSize-1 );
        assert( Cba_FonRight(p, iFon) == 0 );
        //Cba_VerificSaveLineFile( p, iObj, pNet->Linefile() );
        // create write ports feeding into this object
        Vec_PtrForEachEntryStart( Vec_Int_t *, vRam, vBox, k, 2 )
        {
            int iObjNew = Cba_ObjAlloc( p, CBA_BOX_RAMWC, 4, 1 );
            int Line = Vec_IntPop( vBox );
            Vec_IntWriteEntry( vBox2Obj, Line, iObjNew );
            if ( Prs_BoxName(pNtk, Line) )
                Cba_ObjSetName( p, iObjNew, Prs_BoxName(pNtk, Line) );
            //Cba_VerificSaveLineFile( p, iObjNew, pInst->Linefile() );
            // connect output
            iFon = Cba_ObjFon0(p, iObjNew);
            Cba_FonSetRange( p, iFon, Cba_NtkHashRange(p, MemSize-1, 0) );
            //sprintf( Buffer, "%s_wp%d", pRamName, k-2 );
            //NameId = Cba_NtkNewStrId( p, Buffer ); 
            NameId = Cba_NtkNewStrId( p, "%s_wp%d", pRamName, k-2 );
            Cba_FonSetName( p, iFon, NameId );
            Cba_NtkSetMap( p, NameId, iFon );
            // connet to RAM object
            Cba_ObjSetFinFon( p, iObj, (k++)-2, iFon );
            Vec_IntFree( vBox );
        }
        Vec_PtrFree( vRam );
    }
    Vec_PtrFreeP( &vAllRams );
 
    // create objects
    Vec_IntClear( &p->vArray0 );
    Prs_NtkForEachBox( pNtk, vBox, i )
    {
        if ( Prs_BoxIsNode(pNtk, i) ) // node
        {
            Type = Prs_BoxNtk(pNtk, i);
            iObj = Cba_ObjAlloc( p, (Cba_ObjType_t)Type, Prs_BoxIONum(pNtk, i)-1, Type == CBA_BOX_ADD ? 2 : 1 );
            Prs_CreateSignalOut( p, Cba_ObjFon0(p, iObj), pNtk, Vec_IntEntry(vBox, 1) ); // node output
        }
        else // box
        {
            Cba_Ntk_t * pBox = NULL; int nInputs, nOutputs = 1;
            char ** pOutNames = NULL, * pNtkName = Prs_NtkStr(pNtk, Prs_BoxNtk(pNtk, i));
            Type = Prs_ManFindType( pNtkName, &nInputs, 1, &pOutNames );
            if ( Type == CBA_BOX_RAMWC )
                continue;
            if ( Type == CBA_OBJ_BOX )
            {
                pBox = Cba_ManNtkFind( p->pDesign, pNtkName );
                if ( pBox == NULL )
                {
                    printf( "Fatal error: Cannot find module \"%s\".\n", pNtkName );
                    continue;
                }
                nInputs = Cba_NtkPiNum(pBox);
                nOutputs = Cba_NtkPoNum(pBox);
            }
            else if ( Type == CBA_BOX_ADD || Type == CBA_BOX_DFFCPL )
                nOutputs = 2;
            else if ( Type == CBA_BOX_NMUX )
            {
                if ( !strncmp(pNtkName, "wide_mux_", strlen("wide_mux_")) )
                    nInputs = 1 + (1 << atoi(pNtkName+strlen("wide_mux_")));
                else if ( !strncmp(pNtkName, "Mux_", strlen("Mux_")) )
                    nInputs = 1 + (1 << atoi(pNtkName+strlen("Mux_")));
                else assert( 0 );
            }
            else if ( Type == CBA_BOX_SEL )
            {
                if ( !strncmp(pNtkName, "wide_select_", strlen("wide_select_")) )
                    nInputs = 1 + atoi(pNtkName+strlen("wide_select_"));
                else if ( !strncmp(pNtkName, "Select_", strlen("Select_")) )
                    nInputs = 1 + atoi(pNtkName+strlen("Select_"));
                else assert( 0 );
            }
            else if ( (Type == CBA_BOX_DFFRS || Type == CBA_BOX_LATCHRS) && !strncmp(pNtkName, "wide_", strlen("wide_")) && !Prs_CreateFlopSetReset(p, pNtk, vBox, NULL, NULL, NULL, NULL) )
                nInputs = atoi(pNtkName+strlen(Type == CBA_BOX_DFFRS ? "wide_dffrs_" : "wide_latchrs_")), nOutputs = 1, Type = CBA_BOX_CONCAT;
            // create object
            iObj = Cba_ObjAlloc( p, (Cba_ObjType_t)Type, nInputs, nOutputs );
            if ( pBox ) Cba_ObjSetFunc( p, iObj, Cba_NtkId(pBox) );
            // mark PO objects
            Cba_NtkCleanMap2( p );
            if ( pBox )
                Cba_NtkForEachPo( pBox, iTerm, k )
                    Cba_NtkSetMap2( p, Cba_ObjName(pBox, iTerm), k+1 );
            else
                for ( k = 0; k < nOutputs; k++ )
                    Cba_NtkSetMap2( p, Cba_NtkStrId(p, pOutNames[k]), k+1 );
            // map box fons
            Vec_IntForEachEntryDouble( vBox, FormId, ActId, k )
                if ( Cba_NtkGetMap2(p, FormId) )
                {
                    iFon = Cba_ObjFon(p, iObj, Cba_NtkGetMap2(p, FormId)-1);
                    Prs_CreateSignalOut( p, iFon, pNtk, ActId );
                }
        }
        Vec_IntWriteEntry( vBox2Obj, i, iObj );
        if ( Prs_BoxName(pNtk, i) )
            Cba_ObjSetName( p, iObj, Prs_BoxName(pNtk, i) );
        //Cba_VerificSaveLineFile( p, iObj, pInst->Linefile() );
    }
 
    // create concatenations for split signals
    if ( Vec_IntSize(&p->vArray0) )
    {
        int Prev = -1, Index = 0;
        Vec_IntSortMulti( &p->vArray0, 3, 0 );
        Vec_IntForEachEntryTriple( &p->vArray0, NameId, RangeId, iFon, i )
        {
            if ( Prev != -1 && Prev != NameId )
                Prs_CreateOutConcat( p, Vec_IntArray(&p->vArray0) + Index, (i - Index)/3 ), Index = i;
            Prev = NameId;         
        }
        Prs_CreateOutConcat( p, Vec_IntArray(&p->vArray0) + Index, (i - Index)/3 ), Index = i;
        //Cba_VerificSaveLineFile( p, iObj, pInst->Linefile() );
    }
 
    // connect objects
    Prs_NtkForEachBox( pNtk, vBox, i )
    {
        iObj = Vec_IntEntry( vBox2Obj, i );
        if ( Prs_BoxIsNode(pNtk, i) ) // node
        {
            Type = Prs_BoxNtk(pNtk, i);
            Vec_IntForEachEntryDoubleStart( vBox, FormId, ActId, k, 2 )
            {
                iFon = Prs_CreateSignalIn( p, pNtk, ActId );
                if ( iFon )
                    Cba_ObjSetFinFon( p, iObj, k/2-1, iFon ); 
            }
        }
        else // box
        {
            int nInputs = -1;
            char ** pInNames = NULL, * pNtkName = Prs_NtkStr(pNtk, Prs_BoxNtk(pNtk, i));
            Type = Prs_ManFindType( pNtkName, &nInputs, 0, &pInNames );
            if ( (Type == CBA_BOX_DFFRS || Type == CBA_BOX_LATCHRS) && !strncmp(pNtkName, "wide_", strlen("wide_")) )
            {
                int IndexSet = -1, IndexRst = -1,  iBitSet = -1, iBitRst = -1;
                int Status = Prs_CreateFlopSetReset( p, pNtk, vBox, &IndexSet, &IndexRst, &iBitSet, &iBitRst );
                if ( Status )
                {
                    Vec_IntWriteEntry( vBox, IndexSet, iBitSet );
                    Vec_IntWriteEntry( vBox, IndexRst, iBitRst );
                    // updated box should be fine
                }
                else
                {
                    int w, Width = atoi( pNtkName + strlen(Type == CBA_BOX_DFFRS ? "wide_dffrs_" : "wide_latchrs_") );
                    assert( Cba_ObjType(p, iObj) == CBA_BOX_CONCAT );
                    // prepare inputs
                    assert( nInputs >= 0 );
                    Cba_NtkCleanMap2( p );
                    for ( k = 0; k < nInputs; k++ )
                        Cba_NtkSetMap2( p, Cba_NtkStrId(p, pInNames[k]), k+1 );
                    // create bit-level objects
                    for ( w = 0; w < Width; w++ )
                    {
                        // create bit-level flop
                        int iObjNew = Cba_ObjAlloc( p, (Cba_ObjType_t)Type, 4, 1 );
                        if ( Prs_BoxName(pNtk, i) )
                        {
                            NameId = Cba_NtkNewStrId( p, "%s[%d]", Prs_NtkStr(pNtk, Prs_BoxName(pNtk, i)), w );
                            Cba_ObjSetName( p, iObjNew, NameId );
                        }
                        //Cba_VerificSaveLineFile( p, iObjNew, pInst->Linefile() );
                        // set output fon
                        iFon = Cba_ObjFon0(p, iObjNew);
                        {
                            NameId = Cba_NtkNewStrId( p, "%s[%d]", Cba_FonNameStr(p, Cba_ObjFon0(p, iObj)), w );
                            Cba_FonSetName( p, iFon, NameId );
                        }
                        // no need to map this name because it may be produced elsewhere
                        //Cba_NtkSetMap( p, NameId, iFon );
                        // add the flop
                        Cba_ObjSetFinFon( p, iObj, Width-1-w, iFon );
                        // create bit-level flops
                        Vec_IntForEachEntryDouble( vBox, FormId, ActId, k )
                            if ( Cba_NtkGetMap2(p, FormId) )
                            {
                                int Index = Cba_NtkGetMap2(p, FormId)-1;
                                iFon = Prs_CreateSignalIn( p, pNtk, ActId );  assert( iFon );
                                // create bit-select node for data/set/reset (but not for clock)
                                if ( Index < 3 ) // not clock
                                    iFon = Prs_CreateSlice( p, iFon, pNtk, 0 );
                                Cba_ObjSetFinFon( p, iObjNew, Index, iFon );
                            }
                    }
                    continue;
                }
            }
            assert( Type == Cba_ObjType(p, iObj) );
            //assert( nInputs == -1 || nInputs == Cba_ObjFinNum(p, iObj) );
            // mark PI objects
            Cba_NtkCleanMap2( p );
            if ( Type == CBA_OBJ_BOX )
            {
                Cba_Ntk_t * pBox = Cba_ObjNtk(p, iObj);
                assert( Cba_NtkPiNum(pBox) == Cba_ObjFinNum(p, iObj) );
                assert( Cba_NtkPoNum(pBox) == Cba_ObjFonNum(p, iObj) );
                Cba_NtkForEachPi( pBox, iTerm, k )
                    Cba_NtkSetMap2( p, Cba_ObjName(pBox, iTerm), k+1 );
            }
            else
            {
                assert( nInputs >= 0 );
                for ( k = 0; k < nInputs; k++ )
                    Cba_NtkSetMap2( p, Cba_NtkStrId(p, pInNames[k]), k+1 );
            }
            // connect box fins
            Vec_IntForEachEntryDouble( vBox, FormId, ActId, k )
                if ( Cba_NtkGetMap2(p, FormId) )
                {
                    int Index = Cba_NtkGetMap2(p, FormId)-1;
                    int nBits = Cba_ObjFinNum(p, iObj);
                    assert( Index < nBits );
                    iFon = Prs_CreateSignalIn( p, pNtk, ActId );
                    if ( iFon )
                        Cba_ObjSetFinFon( p, iObj, Index, iFon );
                }
            // special cases
            if ( Type == CBA_BOX_NMUX || Type == CBA_BOX_SEL )
            {
                int FonCat = Cba_ObjFinFon( p, iObj, 1 );
                int nBits  = Cba_FonRangeSize( p, FonCat );
                int nParts = Cba_ObjFinNum(p, iObj) - 1;
                int Slice  = nBits / nParts;
                int nFins = Cba_ObjFinNum(p, iObj);
                assert( Cba_ObjFinNum(p, iObj) >= 2 );
                assert( Slice * nParts == nBits );
                assert( nFins == 1 + nParts );
                Cba_ObjCleanFinFon( p, iObj, 1 );
                // create buffer for the constant
                if ( FonCat < 0 ) 
                {
                    int iObjNew = Cba_ObjAlloc( p, CBA_BOX_BUF, 1, 1 );
                    Cba_ObjSetFinFon( p, iObjNew, 0, FonCat );
                    FonCat = Cba_ObjFon0( p, iObjNew );
                    NameId = Cba_NtkNewStrId( p, "_buf_const_%d", iObjNew );
                    Cba_FonSetName( p, FonCat, NameId );
                    Cba_FonSetRange( p, FonCat, Cba_NtkHashRange(p, nBits-1, 0) );
                }
                for ( k = 0; k < nParts; k++ )
                {
//                    iFon = Prs_CreateSlice( p, FonCat, pNtk, Cba_NtkHashRange(p, (nParts-1-k)*Slice+Slice-1, (nParts-1-k)*Slice) );
                    iFon = Prs_CreateSlice( p, FonCat, pNtk, Cba_NtkHashRange(p, k*Slice+Slice-1, k*Slice) );
                    Cba_ObjSetFinFon( p, iObj, k+1, iFon );
                }
            }
        }
        // if carry-in is not supplied, use constant 0
        if ( Type == CBA_BOX_ADD && Cba_ObjFinFon(p, iObj, 0) == 0 )
            Cba_ObjSetFinFon( p, iObj, 0, Cba_FonFromConst(1) );
        // if set or reset are not supplied, use constant 0
        if ( Type == CBA_BOX_DFFRS && Cba_ObjFinFon(p, iObj, 1) == 0 )
            Cba_ObjSetFinFon( p, iObj, 1, Cba_FonFromConst(1) );
        if ( Type == CBA_BOX_DFFRS && Cba_ObjFinFon(p, iObj, 2) == 0 )
            Cba_ObjSetFinFon( p, iObj, 2, Cba_FonFromConst(1) );
    }
    Vec_IntFree( vBox2Obj );
    // connect outputs
    Vec_IntForEachEntryTwo( &pNtk->vOutputs, &pNtk->vOutputsR, NameId, RangeId, i )
    {
        iObj = Cba_NtkPo( p, i );
        assert( NameId == Cba_ObjName(p, iObj) ); // direct name
        iFon = Prs_CreateVerilogFindFon( p, NameId );
        if ( !iFon ) 
            continue;
        Cba_ObjSetFinFon( p, iObj, 0, iFon );
        if ( RangeId )
        {
            assert( Cba_NtkRangeLeft(p, Abc_Lit2Var(RangeId))  == Cba_FonLeft(p, iFon) );
            assert( Cba_NtkRangeRight(p, Abc_Lit2Var(RangeId)) == Cba_FonRight(p, iFon) );
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Prs_CreateVerilogPio()

void Prs_CreateVerilogPio	(	Cba_Ntk_t *	p,
		Prs_Ntk_t *	pNtk )

Definition at line 1780 of file cbaReadVer.c.

{
    int i, NameId, RangeId, iObj, iFon;
    Cba_NtkCleanObjFuncs( p );
    Cba_NtkCleanObjNames( p );
    Cba_NtkCleanFonNames( p );
    Cba_NtkCleanFonRanges( p );
    // create inputs
    Cba_NtkCleanMap( p );
    assert( Vec_IntSize(&pNtk->vInouts) == 0 );
    Vec_IntForEachEntryTwo( &pNtk->vInputs, &pNtk->vInputsR, NameId, RangeId, i )
    {
        iObj = Cba_ObjAlloc( p, CBA_OBJ_PI, 0, 1 );
        Cba_ObjSetName( p, iObj, NameId ); // direct name
        iFon = Cba_ObjFon0(p, iObj);
        Cba_FonSetRangeSign( p, iFon, RangeId );
        Cba_FonSetName( p, iFon, NameId );
        Cba_NtkSetMap( p, NameId, iObj );
    }
    // create outputs
    Vec_IntForEachEntryTwo( &pNtk->vOutputs, &pNtk->vOutputsR, NameId, RangeId, i )
    {
        iObj = Cba_ObjAlloc( p, CBA_OBJ_PO, 1, 0 );
        Cba_ObjSetName( p, iObj, NameId ); // direct name
        Cba_NtkSetMap( p, NameId, iObj );
    }
    // create order
    Vec_IntForEachEntry( &pNtk->vOrder, NameId, i )
    {
        iObj = Prs_CreateVerilogFindFon( p, Abc_Lit2Var2(NameId) ); // labeled name
        if ( iObj )
            Vec_IntPush( &p->vOrder, iObj );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Prs_ManBuildCbaVerilog()

Cba_Man_t * Prs_ManBuildCbaVerilog	(	char *	pFileName,
		Vec_Ptr_t *	vDes )

Definition at line 2123 of file cbaReadVer.c.

{
    Prs_Ntk_t * pPrsNtk; int i, fError = 0;
    Prs_Ntk_t * pPrsRoot = Prs_ManRoot(vDes);
    // start the manager
    Abc_Nam_t * pStrs = Abc_NamRef(pPrsRoot->pStrs);
    Abc_Nam_t * pFuns = Abc_NamRef(pPrsRoot->pFuns);
    Abc_Nam_t * pMods = Abc_NamStart( 100, 24 );
    Cba_Man_t * p = Cba_ManAlloc( pFileName, Vec_PtrSize(vDes), pStrs, pFuns, pMods, Hash_IntManRef(pPrsRoot->vHash) );
    // initialize networks
    Vec_PtrForEachEntry( Prs_Ntk_t *, vDes, pPrsNtk, i )
    {
        Cba_Ntk_t * pNtk = Cba_NtkAlloc( p, Prs_NtkId(pPrsNtk), Prs_NtkPiNum(pPrsNtk), Prs_NtkPoNum(pPrsNtk), Prs_NtkObjNum(pPrsNtk), 100, 100 );
        Prs_CreateVerilogPio( pNtk, pPrsNtk );
        Cba_NtkAdd( p, pNtk );
    }
    // create networks
    Vec_PtrForEachEntry( Prs_Ntk_t *, vDes, pPrsNtk, i )
    {
        printf( "Building module \"%s\"...\n", Prs_NtkName(pPrsNtk) );
        fError = Prs_CreateVerilogNtk( Cba_ManNtk(p, i+1), pPrsNtk );
        if ( fError )
            break;
    }
    if ( fError )
        printf( "Quitting because of errors.\n" );
    else
        Cba_ManPrepareSeq( p );
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Prs_ManPrintModules()

void Prs_ManPrintModules

(

Prs_Man_t *

p

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1347 of file cbaReadVer.c.

{
    char * pName; int i; 
    printf( "Succeeded parsing %d models:\n", Vec_IntSize(&p->vSucceeded) );
    Prs_ManForEachNameVec( &p->vSucceeded, p, pName, i )
        printf( " %s", pName );
    printf( "\n" );
    printf( "Skipped %d known models:\n", Vec_IntSize(&p->vKnown) );
    Prs_ManForEachNameVec( &p->vKnown, p, pName, i )
        printf( " %s", pName );
    printf( "\n" );
    printf( "Skipped %d failed models:\n", Vec_IntSize(&p->vFailed) );
    Prs_ManForEachNameVec( &p->vFailed, p, pName, i )
        printf( " %s", pName );
    printf( "\n" );
}

Here is the caller graph for this function:

Prs_ManReadSignalList()

int Prs_ManReadSignalList	(	Prs_Man_t *	p,
		Vec_Int_t *	vTemp,
		char	LastSymb,
		int	fAddForm )

Definition at line 624 of file cbaReadVer.c.

{
    Vec_IntClear( vTemp );
    while ( 1 )
    {
        int Item = Prs_ManReadSignal(p);
        if ( Item == 0 )                    return Prs_ManErrorSet(p, "Cannot read signal in the list.", 0);
        if ( fAddForm )
            Vec_IntPush( vTemp, 0 );
        Vec_IntPush( vTemp, Item );
        if ( Prs_ManIsChar(p, LastSymb) )   break;
        if ( !Prs_ManIsChar(p, ',') )       return Prs_ManErrorSet(p, "Expecting comma in the list.", 0);
        p->pCur++;
    }
    return 1;
}

Prs_ManReadVerilog()

Vec_Ptr_t * Prs_ManReadVerilog

(

char *

pFileName

)

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1375 of file cbaReadVer.c.

{
    Vec_Ptr_t * vPrs = NULL;
    Prs_Man_t * p = Prs_ManAlloc( pFileName );
    if ( p == NULL )
        return NULL;
    Abc_NamStrFindOrAdd( p->pFuns, "1\'b0", NULL );
    Abc_NamStrFindOrAdd( p->pFuns, "1\'b1", NULL );
    Abc_NamStrFindOrAdd( p->pFuns, "1\'bx", NULL );
    Abc_NamStrFindOrAdd( p->pFuns, "1\'bz", NULL );
    Prs_NtkAddVerilogDirectives( p );
    Prs_ManReadDesign( p );   
    Prs_ManPrintModules( p );
    if ( Prs_ManErrorPrint(p) )
        ABC_SWAP( Vec_Ptr_t *, vPrs, p->vNtks );
    Prs_ManFree( p );
    return vPrs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Prs_ManReadVerilogTest()

void Prs_ManReadVerilogTest

(

char *

pFileName

)

Definition at line 1394 of file cbaReadVer.c.

{
    abctime clk = Abc_Clock();
    Vec_Ptr_t * vPrs = Prs_ManReadVerilog( pFileName );
    if ( !vPrs ) return;
    printf( "Finished reading %d networks. ", Vec_PtrSize(vPrs) );
    printf( "NameIDs = %d. ", Abc_NamObjNumMax(Prs_ManNameMan(vPrs)) );
    printf( "Memory = %.2f MB. ", 1.0*Prs_ManMemory(vPrs)/(1<<20) );
    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
    Prs_ManWriteVerilog( Extra_FileNameGenericAppend(pFileName, "_out.v"), vPrs );
//    Abc_NamPrint( Prs_ManNameMan(vPrs) );
    Prs_ManVecFree( vPrs );
}

Here is the call graph for this function:

Prs_NtkAddVerilogDirectives()

void Prs_NtkAddVerilogDirectives

(

Prs_Man_t *

p

)

ITERATORS ///.

FUNCTION DECLARATIONS ///

Definition at line 51 of file cbaReadVer.c.

{
    int i;
    for ( i = 1; s_VerTypes[i]; i++ )
        Abc_NamStrFindOrAdd( p->pStrs, (char *)s_VerTypes[i],   NULL );
    assert( Abc_NamObjNumMax(p->pStrs) == i );
}

Here is the call graph for this function:

Here is the caller graph for this function: