wln.h File Reference

#include "aig/gia/gia.h"
#include "misc/vec/vecHash.h"
#include "misc/extra/extra.h"
#include "misc/util/utilNam.h"
#include "misc/util/utilTruth.h"
#include "aig/miniaig/abcOper.h"

Include dependency graph for wln.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	Wln_Vec_t_
struct	Wln_Ntk_t_

Macros
#define	Wln_NtkForEachObj(p, i)
	MACRO DEFINITIONS ///.
#define	Wln_NtkForEachObjReverse(p, i)
#define	Wln_NtkForEachObjInternal(p, i)
#define	Wln_NtkForEachPi(p, iPi, i)
#define	Wln_NtkForEachPo(p, iPo, i)
#define	Wln_NtkForEachCi(p, iCi, i)
#define	Wln_NtkForEachCo(p, iCo, i)
#define	Wln_NtkForEachFf(p, iFf, i)
#define	Wln_ObjForEachFanin(p, iObj, iFanin, i)
#define	Wln_ObjForEachFaninReverse(pObj, iFanin, i)
#define	Wln_ObjForEachFanoutStatic(p, iObj, iFanout, i)

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Wln_Vec_t_	Wln_Vec_t
	INCLUDES ///.
typedef struct Wln_Ntk_t_	Wln_Ntk_t
typedef struct Rtl_Lib_t_	Rtl_Lib_t

Functions
Wln_Ntk_t *	Wln_ReadNdr (char *pFileName)
	FUNCTION DECLARATIONS ///.
void	Wln_WriteNdr (Wln_Ntk_t *pNtk, char *pFileName)
Wln_Ntk_t *	Wln_NtkFromNdr (void *pData, int fDump)
void *	Wln_NtkToNdr (Wln_Ntk_t *pNtk)
	DECLARATIONS ///.
Wln_Ntk_t *	Wln_NtkAlloc (char *pName, int nObjsMax)
	DECLARATIONS ///.
void	Wln_NtkFree (Wln_Ntk_t *p)
int	Wln_NtkMemUsage (Wln_Ntk_t *p)
void	Wln_NtkPrint (Wln_Ntk_t *p)
Wln_Ntk_t *	Wln_NtkDupDfs (Wln_Ntk_t *p)
int	Wln_NtkIsAcyclic (Wln_Ntk_t *p)
void	Wln_NtkCreateRefs (Wln_Ntk_t *p)
void	Wln_NtkStartFaninMap (Wln_Ntk_t *p, Vec_Int_t *vFaninMap, int nMulti)
void	Wln_NtkStartFanoutMap (Wln_Ntk_t *p, Vec_Int_t *vFanoutMap, Vec_Int_t *vFanoutNums, int nMulti)
void	Wln_NtkStaticFanoutStart (Wln_Ntk_t *p)
void	Wln_NtkStaticFanoutStop (Wln_Ntk_t *p)
void	Wln_NtkStaticFanoutTest (Wln_Ntk_t *p)
char *	Wln_ObjName (Wln_Ntk_t *p, int iObj)
	DECLARATIONS ///.
char *	Wln_ObjConstString (Wln_Ntk_t *p, int iObj)
void	Wln_ObjUpdateType (Wln_Ntk_t *p, int iObj, int Type)
void	Wln_ObjSetConst (Wln_Ntk_t *p, int iObj, int NameId)
void	Wln_ObjSetSlice (Wln_Ntk_t *p, int iObj, int SliceId)
void	Wln_ObjAddFanin (Wln_Ntk_t *p, int iObj, int i)
int	Wln_ObjAddFanins (Wln_Ntk_t *p, int iObj, Vec_Int_t *vFanins)
int	Wln_ObjAlloc (Wln_Ntk_t *p, int Type, int Signed, int End, int Beg)
int	Wln_ObjClone (Wln_Ntk_t *pNew, Wln_Ntk_t *p, int iObj)
int	Wln_ObjCreateCo (Wln_Ntk_t *p, int iFanin)
void	Wln_ObjPrint (Wln_Ntk_t *p, int iObj)
Vec_Int_t *	Wln_NtkRetime (Wln_Ntk_t *p, int fIgnoreIO, int fSkipSimple, int fVerbose)
void	Wln_NtkRetimeCreateDelayInfo (Wln_Ntk_t *pNtk)
void	Wln_WriteVer (Wln_Ntk_t *p, char *pFileName)
Rtl_Lib_t *	Rtl_LibReadFile (char *pFileName, char *pFileSpec)
void	Rtl_LibFree (Rtl_Lib_t *p)

Macro Definition Documentation

Wln_NtkForEachCi

#define Wln_NtkForEachCi	(		p,
			iCi,
			i )

Value:

    for ( i = 0; (i < Wln_NtkCiNum(p)) && (((iCi) = Wln_NtkCi(p, i)), 1); i++ )

Definition at line 198 of file wln.h.

#define Wln_NtkForEachCi( p, iCi, i )                                               \
    for ( i = 0; (i < Wln_NtkCiNum(p)) && (((iCi) = Wln_NtkCi(p, i)), 1); i++ )

Wln_NtkForEachCo

#define Wln_NtkForEachCo	(		p,
			iCo,
			i )

Value:

    for ( i = 0; (i < Wln_NtkCoNum(p)) && (((iCo) = Wln_NtkCo(p, i)), 1); i++ )

Definition at line 200 of file wln.h.

#define Wln_NtkForEachCo( p, iCo, i )                                               \
    for ( i = 0; (i < Wln_NtkCoNum(p)) && (((iCo) = Wln_NtkCo(p, i)), 1); i++ )

Wln_NtkForEachFf

#define Wln_NtkForEachFf	(		p,
			iFf,
			i )

Value:

    for ( i = 0; (i < Wln_NtkFfNum(p)) && (((iFf) = Wln_NtkFf(p, i)), 1); i++ )

Definition at line 202 of file wln.h.

#define Wln_NtkForEachFf( p, iFf, i )                                               \
    for ( i = 0; (i < Wln_NtkFfNum(p)) && (((iFf) = Wln_NtkFf(p, i)), 1); i++ )

Wln_NtkForEachObj

#define Wln_NtkForEachObj	(		p,
			i )

Value:

    for ( i = 1; i < Wln_NtkObjNum(p); i++ )

MACRO DEFINITIONS ///.

ITERATORS ///

Definition at line 187 of file wln.h.

#define Wln_NtkForEachObj( p, i )                                                   \
    for ( i = 1; i < Wln_NtkObjNum(p); i++ )

Wln_NtkForEachObjInternal

#define Wln_NtkForEachObjInternal	(		p,
			i )

Value:

    for ( i = 1; i < Wln_NtkObjNum(p); i++ ) if ( Wln_ObjIsCio(p, i) ) {} else

Definition at line 191 of file wln.h.

#define Wln_NtkForEachObjInternal( p, i )                                           \
    for ( i = 1; i < Wln_NtkObjNum(p); i++ ) if ( Wln_ObjIsCio(p, i) ) {} else 

Wln_NtkForEachObjReverse

#define Wln_NtkForEachObjReverse	(		p,
			i )

Value:

    for ( i = Wln_NtkObjNum(p) - 1; i >  0; i-- )

Definition at line 189 of file wln.h.

#define Wln_NtkForEachObjReverse( p, i )                                            \
    for ( i = Wln_NtkObjNum(p) - 1; i >  0; i-- )

Wln_NtkForEachPi

#define Wln_NtkForEachPi	(		p,
			iPi,
			i )

Value:

    for ( i = 0; (i < Wln_NtkPiNum(p)) && (((iPi) = Wln_NtkCi(p, i)), 1); i++ )

Definition at line 194 of file wln.h.

#define Wln_NtkForEachPi( p, iPi, i )                                               \
    for ( i = 0; (i < Wln_NtkPiNum(p)) && (((iPi) = Wln_NtkCi(p, i)), 1); i++ )

Wln_NtkForEachPo

#define Wln_NtkForEachPo	(		p,
			iPo,
			i )

Value:

    for ( i = 0; (i < Wln_NtkPoNum(p)) && (((iPo) = Wln_NtkCo(p, i)), 1); i++ )

Definition at line 196 of file wln.h.

#define Wln_NtkForEachPo( p, iPo, i )                                               \
    for ( i = 0; (i < Wln_NtkPoNum(p)) && (((iPo) = Wln_NtkCo(p, i)), 1); i++ )

Wln_ObjForEachFanin

#define Wln_ObjForEachFanin	(		p,
			iObj,
			iFanin,
			i )

Value:

    for ( i = 0; (i < Wln_ObjFaninNum(p, iObj)) && (((iFanin) = Wln_ObjFanin(p, iObj, i)), 1); i++ ) if ( !iFanin ) {} else

Definition at line 205 of file wln.h.

#define Wln_ObjForEachFanin( p, iObj, iFanin, i )                                   \
    for ( i = 0; (i < Wln_ObjFaninNum(p, iObj)) && (((iFanin) = Wln_ObjFanin(p, iObj, i)), 1); i++ ) if ( !iFanin ) {} else

Wln_ObjForEachFaninReverse

#define Wln_ObjForEachFaninReverse	(		pObj,
			iFanin,
			i )

Value:

    for ( i = Wln_ObjFaninNum(p, iObj) - 1; (i >= 0) && (((iFanin) = Wln_ObjFanin(p, iObj, i)), 1); i-- ) if ( !iFanin ) {} else

Definition at line 207 of file wln.h.

#define Wln_ObjForEachFaninReverse( pObj, iFanin, i )                               \
    for ( i = Wln_ObjFaninNum(p, iObj) - 1; (i >= 0) && (((iFanin) = Wln_ObjFanin(p, iObj, i)), 1); i-- ) if ( !iFanin ) {} else

Wln_ObjForEachFanoutStatic

#define Wln_ObjForEachFanoutStatic	(		p,
			iObj,
			iFanout,
			i )

Value:

    for ( i = 0; (i < Wln_ObjRefs(p, iObj)) && (((iFanout) = Wln_ObjFanout(p, iObj, i)), 1); i++ )

Definition at line 210 of file wln.h.

#define Wln_ObjForEachFanoutStatic( p, iObj, iFanout, i )                           \
    for ( i = 0; (i < Wln_ObjRefs(p, iObj)) && (((iFanout) = Wln_ObjFanout(p, iObj, i)), 1); i++ )

Typedef Documentation

Rtl_Lib_t

typedef struct Rtl_Lib_t_ Rtl_Lib_t

Definition at line 255 of file wln.h.

Wln_Ntk_t

typedef struct Wln_Ntk_t_ Wln_Ntk_t

Definition at line 55 of file wln.h.

Wln_Vec_t

typedef typedefABC_NAMESPACE_HEADER_START struct Wln_Vec_t_ Wln_Vec_t

INCLUDES ///.

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

FileName [wlc.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Verilog parser.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - August 22, 2014.]

Revision [

Id

wlc.h,v 1.00 2014/09/12 00:00:00 alanmi Exp

] PARAMETERS /// BASIC TYPES ///

Definition at line 46 of file wln.h.

Function Documentation

Rtl_LibFree()

void Rtl_LibFree ( Rtl_Lib_t * p )

extern

Definition at line 318 of file wlnRead.c.

{
    Rtl_Ntk_t * pNtk; int i;
    Vec_PtrForEachEntry( Rtl_Ntk_t *, p->vNtks, pNtk, i )
        Rtl_NtkFree( pNtk );    
    ABC_FREE( p->vConsts.pArray );
    ABC_FREE( p->vSlices.pArray );
    ABC_FREE( p->vConcats.pArray );
    ABC_FREE( p->vAttrTemp.pArray );
    for ( i = 0; i < TEMP_NUM; i++ )
        ABC_FREE( p->vTemp[i].pArray );
    Vec_IntFreeP( &p->vMap );
    Vec_IntFreeP( &p->vDirects );
    Vec_IntFreeP( &p->vInverses );
    Vec_IntFreeP( &p->vTokens );
    Abc_NamStop( p->pManName );
    Vec_PtrFree( p->vNtks );
    ABC_FREE( p->pSpec );
    ABC_FREE( p );
}

Here is the call graph for this function:

Rtl_LibReadFile()

Rtl_Lib_t * Rtl_LibReadFile ( char * pFileName, char * pFileSpec )

extern

Definition at line 1492 of file wlnRead.c.

{
    Rtl_Lib_t * p = Rtl_LibAlloc(); int i, Entry;
    p->pSpec      = Abc_UtilStrsav( pFileSpec );
    p->pManName   = Abc_NamStart( 1000, 50 );
    p->vTokens    = Rtl_NtkReadFile( pFileName, p->pManName );
    Rtl_LibDeriveMap( p );
    Vec_IntClear( &p->vAttrTemp );
    Vec_IntForEachEntry( p->vTokens, Entry, i )
        if ( Entry == p->pMap[RTL_MODULE] )
            i = Rtl_NtkReadNtk( p, i+1 );
        else if ( Entry == p->pMap[RTL_ATTRIBUTE] )
            i = Rtl_NtkReadAttribute2( p, i+1 );
    Rtl_LibSetParents( p );
    Rtl_LibReorderModules( p );
    Rtl_LibOrderWires( p );
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkAlloc()

Wln_Ntk_t * Wln_NtkAlloc ( char * pName, int nObjsMax )

extern

DECLARATIONS ///.

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

FileName [wlnNtk.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Word-level network.]

Synopsis [Network construction procedures.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - September 23, 2018.]

Revision [

Id

wlnNtk.c,v 1.00 2018/09/23 00:00:00 alanmi Exp

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

Synopsis [Creating networks.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file wlnNtk.c.

{
    Wln_Ntk_t * p; int i;
    p = ABC_CALLOC( Wln_Ntk_t, 1 );
    p->pName = pName ? Extra_FileNameGeneric( pName ) : NULL;
    Vec_IntGrow( &p->vCis, 111 );
    Vec_IntGrow( &p->vCos, 111 );
    Vec_IntGrow( &p->vFfs, 111 );
    Vec_IntGrow( &p->vTypes,  nObjsMax+1 );
    Vec_StrGrow( &p->vSigns,  nObjsMax+1 );
    Vec_IntGrow( &p->vRanges, nObjsMax+1 );
    Vec_IntPush( &p->vTypes,  -1 );
    Vec_StrPush( &p->vSigns,  -1 );
    Vec_IntPush( &p->vRanges, -1 );
    p->vFanins = ABC_CALLOC( Wln_Vec_t, nObjsMax+1 );
    p->pRanges = Hash_IntManStart( 1000 );
    for ( i = 0; i < 65; i++ )
        Hash_Int2ManInsert( p->pRanges, i, i, 0 );
    for ( i = 1; i < 64; i++ )
        Hash_Int2ManInsert( p->pRanges, i, 0, 0 );
    assert( Hash_IntManEntryNum(p->pRanges) == 128 );
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkCreateRefs()

void Wln_NtkCreateRefs ( Wln_Ntk_t * p )

extern

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

Synopsis [Create fanin/fanout map.]

Description []

SideEffects []

SeeAlso []

Definition at line 357 of file wlnNtk.c.

{
    int k, iObj, iFanin;
    Wln_NtkCleanRefs( p );
    Wln_NtkForEachObj( p, iObj )
        Wln_ObjForEachFanin( p, iObj, iFanin, k )
            Wln_ObjRefsInc( p, iFanin );
}

Here is the caller graph for this function:

Wln_NtkDupDfs()

Wln_Ntk_t * Wln_NtkDupDfs ( Wln_Ntk_t * p )

extern

Definition at line 325 of file wlnNtk.c.

{
    int i, k, iObj, iFanin;
    Wln_Ntk_t * pNew = Wln_NtkAlloc( p->pName, Wln_NtkObjNum(p) );
    pNew->fSmtLib = p->fSmtLib;
    if ( p->pSpec ) pNew->pSpec = Abc_UtilStrsav( p->pSpec );
    Wln_NtkCleanCopy( p );
    Wln_NtkForEachCi( p, iObj, i )
        Wln_ObjDup( pNew, p, iObj );
    Wln_NtkForEachFf( p, iObj, i )
        Wln_ObjSetCopy( p, iObj, Wln_ObjClone(pNew, p, iObj) );
    Wln_NtkForEachCo( p, iObj, i )
        Wln_NtkDupDfs_rec( pNew, p, iObj );
    Wln_NtkForEachFf( p, iObj, i )
        Wln_ObjForEachFanin( p, iObj, iFanin, k )
            Wln_ObjAddFanin( pNew, Wln_ObjCopy(p, iObj), Wln_NtkDupDfs_rec(pNew, p, iFanin) );
    if ( Wln_NtkHasNameId(p) )
        Wln_NtkTransferNames( pNew, p );
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkFree()

void Wln_NtkFree ( Wln_Ntk_t * p )

extern

Definition at line 68 of file wlnNtk.c.

{
    int i;
    for ( i = 0; i < Wln_NtkObjNum(p); i++ )
        if ( Wln_ObjFaninNum(p, i) > 2 ) 
            ABC_FREE( p->vFanins[i].pArray[0] );
    ABC_FREE( p->vFanins );
 
    if ( p->pRanges )  Hash_IntManStop( p->pRanges );
    if ( p->pManName ) Abc_NamStop( p->pManName );
 
    ABC_FREE( p->vCis.pArray );
    ABC_FREE( p->vCos.pArray );
    ABC_FREE( p->vFfs.pArray );
 
    ABC_FREE( p->vTypes.pArray );
    ABC_FREE( p->vSigns.pArray );
    ABC_FREE( p->vRanges.pArray );
    ABC_FREE( p->vNameIds.pArray );
    ABC_FREE( p->vInstIds.pArray );
    ABC_FREE( p->vTravIds.pArray );
    ABC_FREE( p->vCopies.pArray );
    ABC_FREE( p->vBits.pArray );
    ABC_FREE( p->vLevels.pArray );
    ABC_FREE( p->vRefs.pArray );
    ABC_FREE( p->vFanout.pArray );
    ABC_FREE( p->vFaninAttrs.pArray );
    ABC_FREE( p->vFaninLists.pArray );
 
    ABC_FREE( p->pName );
    ABC_FREE( p->pSpec );
    ABC_FREE( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkFromNdr()

Wln_Ntk_t * Wln_NtkFromNdr ( void * pData, int fDump )

extern

Definition at line 182 of file wlnNdr.c.

{
    Ndr_Data_t * p = (Ndr_Data_t *)pData;  
    Vec_Int_t * vName2Obj, * vFanins = Vec_IntAlloc( 100 );
    Vec_Ptr_t * vConstStrings = Vec_PtrAlloc( 100 );
    int Mod = 2, i, k, iFanin, iObj, Obj, * pArray, nDigits, fFound, NameId, NameIdMax;
    Wln_Ntk_t * pTemp, * pNtk = Wln_NtkAlloc( "top", Ndr_DataObjNum(p, Mod) );
    Wln_NtkCheckIntegrity( pData );
    //pNtk->pSpec = Abc_UtilStrsav( pFileName );
    // construct network and save name IDs
    Wln_NtkCleanNameId( pNtk );
    Wln_NtkCleanInstId( pNtk );
    Ndr_ModForEachPi( p, Mod, Obj )
    {
        int End, Beg, Signed = Ndr_ObjGetRange(p, Obj, &End, &Beg);
        int iObj = Wln_ObjAlloc( pNtk, ABC_OPER_CI, Signed, End, Beg );
        int NameId = Ndr_ObjReadBody( p, Obj, NDR_OUTPUT );
        int InstId = Ndr_ObjReadBody( p, Obj, NDR_NAME );
        Wln_ObjSetNameId( pNtk, iObj, NameId );
        if ( InstId > 0 ) Wln_ObjSetInstId( pNtk, iObj, InstId );
    }
    Ndr_ModForEachNode( p, Mod, Obj )
    {
        int End, Beg, Signed = Ndr_ObjGetRange(p, Obj, &End, &Beg);
        int Type    = Ndr_ObjReadBody( p, Obj, NDR_OPERTYPE );
        int nArray  = Ndr_ObjReadArray( p, Obj, NDR_INPUT, &pArray );
        Vec_Int_t F = {nArray, nArray, pArray}, * vTemp = &F;
        int iObj    = Wln_ObjAlloc( pNtk, Type, Signed, End, Beg );
        int NameId  = Ndr_ObjReadBody( p, Obj, NDR_OUTPUT );
        int InstId  = Ndr_ObjReadBody( p, Obj, NDR_NAME );
        Vec_IntClear( vFanins );
        Vec_IntAppend( vFanins, vTemp );
        assert( Type != ABC_OPER_DFF );
        if ( Wln_ObjIsSlice(pNtk, iObj) )
            Wln_ObjSetSlice( pNtk, iObj, Hash_Int2ManInsert(pNtk->pRanges, End, Beg, 0) );
        else if ( Wln_ObjIsConst(pNtk, iObj) )
            Vec_PtrPush( vConstStrings, (char *)Ndr_ObjReadBodyP(p, Obj, NDR_FUNCTION) );
//        else if ( Type == ABC_OPER_BIT_MUX && Vec_IntSize(vFanins) == 3 )
//            ABC_SWAP( int, Wln_ObjFanins(pNtk, iObj)[1], Wln_ObjFanins(pNtk, iObj)[2] );
        Wln_ObjAddFanins( pNtk, iObj, vFanins );
        Wln_ObjSetNameId( pNtk, iObj, NameId );
        if ( InstId > 0 ) Wln_ObjSetInstId( pNtk, iObj, InstId );
        if ( Type == ABC_OPER_ARI_SMUL )
        {
            assert( Wln_ObjFaninNum(pNtk, iObj) == 2 );
            Wln_ObjSetSigned( pNtk, Wln_ObjFanin0(pNtk, iObj) );
            Wln_ObjSetSigned( pNtk, Wln_ObjFanin1(pNtk, iObj) );
        }
    }
    // mark primary outputs
    Ndr_ModForEachPo( p, Mod, Obj )
    {
        int End, Beg, Signed = Ndr_ObjGetRange(p, Obj, &End, &Beg);
        int nArray  = Ndr_ObjReadArray( p, Obj, NDR_INPUT, &pArray );
        int iObj    = Wln_ObjAlloc( pNtk, ABC_OPER_CO, Signed, End, Beg );
        int NameId  = Ndr_ObjReadBody( p, Obj, NDR_OUTPUT );
        int InstId  = Ndr_ObjReadBody( p, Obj, NDR_NAME );
        assert( nArray == 1 && NameId == -1 && InstId == -1 );
        Wln_ObjAddFanin( pNtk, iObj, pArray[0] );
    }
    Vec_IntFree( vFanins );
    // remove instance names if they are not given
    //Vec_IntPrint( &pNtk->vInstIds );
    if ( Vec_IntCountPositive(&pNtk->vInstIds) == 0 )
        Vec_IntErase( &pNtk->vInstIds );
    // map name IDs into object IDs
    vName2Obj = Vec_IntInvert( &pNtk->vNameIds, 0 );
    Wln_NtkForEachObj( pNtk, i )
        Wln_ObjForEachFanin( pNtk, i, iFanin, k )
            Wln_ObjSetFanin( pNtk, i, k, Vec_IntEntry(vName2Obj, iFanin) );
    Vec_IntFree(vName2Obj);
    // create fake object names
    NameIdMax = Vec_IntFindMax(&pNtk->vNameIds);
    nDigits = Abc_Base10Log( NameIdMax+1 );
    pNtk->pManName = Abc_NamStart( NameIdMax+1, 10 );
    for ( i = 1; i <= NameIdMax; i++ )
    {
        char pName[1000]; sprintf( pName, "s%0*d", (unsigned char)nDigits, i );
        NameId = Abc_NamStrFindOrAdd( pNtk->pManName, pName, &fFound );
        assert( !fFound && i == NameId );
    }
    // add const strings
    i = 0;
    Wln_NtkForEachObj( pNtk, iObj )
        if ( Wln_ObjIsConst(pNtk, iObj) )
            Wln_ObjSetConst( pNtk, iObj, Abc_NamStrFindOrAdd(pNtk->pManName, (char *)Vec_PtrEntry(vConstStrings, i++), NULL) );
    assert( i == Vec_PtrSize(vConstStrings) );
    Vec_PtrFree( vConstStrings );
    //Ndr_NtkPrintObjects( pNtk );
    Wln_WriteVer( pNtk, "temp_ndr.v" );
    printf( "Dumped design \"%s\" into file \"temp_ndr.v\".\n", pNtk->pName );
    if ( !Wln_NtkIsAcyclic(pNtk) )
    {
        Wln_NtkFree(pNtk);
        return NULL;
    }
    // derive topological order
    pNtk = Wln_NtkDupDfs( pTemp = pNtk );
    Wln_NtkFree( pTemp );
    //Ndr_NtkPrintObjects( pNtk );
    //pNtk->fMemPorts = 1;          // the network contains memory ports
    //pNtk->fEasyFfs = 1;           // the network contains simple flops
    return pNtk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkIsAcyclic()

int Wln_NtkIsAcyclic ( Wln_Ntk_t * p )

extern

Wln_ObjRefs(p, iObj) &&

Definition at line 192 of file wlnNtk.c.

{
    int fAcyclic, i, iObj, nUnvisited = 0 ;
    // set the traversal ID for this DFS ordering
    Wln_NtkIncrementTravId( p );   
    Wln_NtkIncrementTravId( p );   
    // iObj->TravId == pNet->nTravIds      means "iObj is on the path"
    // iObj->TravId == pNet->nTravIds - 1  means "iObj is visited but is not on the path"
    // iObj->TravId <  pNet->nTravIds - 1  means "iObj is not visited"
    // traverse the network to detect cycles
    fAcyclic = 1;
    Wln_NtkForEachCo( p, iObj, i )
    {
        // traverse the output logic cone
        if ( (fAcyclic = Wln_NtkIsAcyclic_rec(p, iObj)) )
            continue;
        // stop as soon as the first loop is detected
        fprintf( stdout, "Primary output %16s (ID %6d)\n", Wln_ObjName(p, iObj), iObj );
        goto finish;
    }
    Wln_NtkForEachFf( p, iObj, i )
    {
        // traverse the output logic cone
        if ( (fAcyclic = Wln_NtkIsAcyclic_rec(p, iObj)) )
            continue;
        // stop as soon as the first loop is detected
        fprintf( stdout, "Flip-flop %16s (ID %6d)\n", Wln_ObjName(p, iObj), iObj );
        goto finish;
    }
    Wln_NtkForEachObj( p, iObj )
        nUnvisited += !Wln_ObjIsTravIdPrevious(p, iObj) && !Wln_ObjIsCi(p, iObj);
    if ( nUnvisited )
    {
        int nSinks = 0;
        Wln_NtkCreateRefs(p);
        printf( "The network has %d objects and %d (%6.2f %%) of them are not connected to the outputs.\n", 
            Wln_NtkObjNum(p), nUnvisited, 100.0*nUnvisited/Wln_NtkObjNum(p) );
        Wln_NtkForEachObj( p, iObj )
            if ( !Wln_ObjRefs(p, iObj) && !Wln_ObjIsCi(p, iObj) && !Wln_ObjIsCo(p, iObj) && !Wln_ObjIsFf(p, iObj) )
                nSinks++;
        if ( nSinks )
        {
            int nPrinted = 0;
            printf( "These unconnected objects feed into %d sink objects without fanout:\n", nSinks );
            Wln_NtkForEachObj( p, iObj )
                if ( !Wln_ObjRefs(p, iObj) && !Wln_ObjIsCi(p, iObj) && !Wln_ObjIsCo(p, iObj) && !Wln_ObjIsFf(p, iObj) )
                {
                    fprintf( stdout, "Node %16s (ID %6d) of type %5s (type ID %2d)\n", 
                        Wln_ObjName(p, iObj), iObj, Abc_OperName(Wln_ObjType(p, iObj)), Wln_ObjType(p, iObj) );
                    if ( ++nPrinted == 5 )
                        break;
                }
            if ( nPrinted < nSinks )
                printf( "...\n" );
        }
        Wln_NtkForEachObj( p, iObj )
            if (  !Wln_ObjIsTravIdPrevious(p, iObj) && !Wln_ObjIsCi(p, iObj) )
            {
                // traverse the output logic cone
                if ( (fAcyclic = Wln_NtkIsAcyclic_rec(p, iObj)) )
                    continue;
                // stop as soon as the first loop is detected
                fprintf( stdout, "Unconnected object %s\n", Wln_ObjName(p, iObj) );
                goto finish;
            }
    }
finish:
    return fAcyclic;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkMemUsage()

int Wln_NtkMemUsage ( Wln_Ntk_t * p )

extern

Definition at line 101 of file wlnNtk.c.

{
    int Mem = sizeof(Wln_Ntk_t);
    Mem += 4 * p->vCis.nCap;
    Mem += 4 * p->vCos.nCap;
    Mem += 4 * p->vFfs.nCap;
    Mem += 1 * p->vTypes.nCap;
    Mem += 4 * p->vRanges.nCap;
    Mem += 4 * p->vNameIds.nCap;
    Mem += 4 * p->vInstIds.nCap;
    Mem += 4 * p->vTravIds.nCap;
    Mem += 4 * p->vCopies.nCap;
    Mem += 4 * p->vBits.nCap;
    Mem += 4 * p->vLevels.nCap;
    Mem += 4 * p->vRefs.nCap;
    Mem += 4 * p->vFanout.nCap;
    Mem += 4 * p->vFaninAttrs.nCap;
    Mem += 4 * p->vFaninLists.nCap;
    Mem += 20 * Hash_IntManEntryNum(p->pRanges);
    Mem += Abc_NamMemUsed(p->pManName);
    return Mem;
}

Here is the call graph for this function:

Wln_NtkPrint()

void Wln_NtkPrint ( Wln_Ntk_t * p )

extern

Definition at line 123 of file wlnNtk.c.

{
    int iObj;
    printf( "Printing %d objects of network \"%s\":\n", Wln_NtkObjNum(p), p->pName );
    Wln_NtkForEachObj( p, iObj )
        Wln_ObjPrint( p, iObj );
    printf( "\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkRetime()

Vec_Int_t * Wln_NtkRetime ( Wln_Ntk_t * p, int fIgnoreIO, int fSkipSimple, int fVerbose )

extern

Definition at line 718 of file wlnRetime.c.

{
    if ( fIgnoreIO )
        Wln_RetMarkPaths( pNtk, fVerbose );
    return Wln_NtkRetime_int( pNtk, fSkipSimple, fVerbose );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkRetimeCreateDelayInfo()

void Wln_NtkRetimeCreateDelayInfo ( Wln_Ntk_t * pNtk )

extern

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

Synopsis [Retiming computation.]

Description []

SideEffects []

SeeAlso []

Definition at line 592 of file wlnRetime.c.

{
    int i, iObj;
//    if ( Wln_NtkHasInstId(pNtk) )
//        Vec_IntErase( &pNtk->vInstIds );
    if ( Wln_NtkHasInstId(pNtk) )
    {
        printf( "Using delays given by the user in the input file.\n" );
        Wln_NtkForEachObj( pNtk, iObj )
            if ( !Wln_ObjIsCio(pNtk, iObj) && !Wln_ObjIsConst(pNtk, iObj) && Wln_ObjInstId(pNtk, iObj) == 0 )
                printf( "Warning: Object %d of type %s has zero delay. Retiming will not work correctly.\n", iObj, Abc_OperName(Wln_ObjType(pNtk, iObj)) );
    }
    else
    {
        printf( "The design has no delay information.\n" );
        Wln_NtkCleanInstId(pNtk);
        Wln_NtkForEachObj( pNtk, iObj )
        {
            if ( Wln_ObjIsFf(pNtk, iObj) || Wln_ObjType(pNtk, iObj) == ABC_OPER_SLICE || Wln_ObjType(pNtk, iObj) == ABC_OPER_CONCAT )
                Wln_ObjSetInstId( pNtk, iObj, 1 );
            else if ( !Wln_ObjIsCio(pNtk, iObj) && Wln_ObjFaninNum(pNtk, iObj) > 0 )
                Wln_ObjSetInstId( pNtk, iObj, 10 );
        }
        Wln_NtkForEachCo( pNtk, iObj, i ) 
        {
            if ( Wln_ObjType(pNtk, Wln_ObjFanin0(pNtk, iObj)) != ABC_OPER_LUT )
                Wln_ObjSetInstId( pNtk, Wln_ObjFanin0(pNtk, iObj), 1 );
        }
        printf( "Assuming default delays: 10 units for most nodes and 1 unit for bit-slice, concat, and buffers driving COs.\n" );
    }
}

Here is the caller graph for this function:

Wln_NtkStartFaninMap()

void Wln_NtkStartFaninMap ( Wln_Ntk_t * p, Vec_Int_t * vFaninMap, int nMulti )

extern

Definition at line 372 of file wlnNtk.c.

{
    int iObj, iOffset = Wln_NtkObjNum(p);
    Vec_IntFill( vFaninMap, iOffset + nMulti * Wln_NtkFaninNum(p), 0 );
    Wln_NtkForEachObj( p, iObj )
    {
        Vec_IntWriteEntry( vFaninMap, iObj, iOffset );
        iOffset += nMulti * Wln_ObjFaninNum(p, iObj);
    }
    assert( iOffset == Vec_IntSize(vFaninMap) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkStartFanoutMap()

void Wln_NtkStartFanoutMap ( Wln_Ntk_t * p, Vec_Int_t * vFanoutMap, Vec_Int_t * vFanoutNums, int nMulti )

extern

Definition at line 383 of file wlnNtk.c.

{
    int iObj, iOffset = Wln_NtkObjNum(p);
    Vec_IntFill( vFanoutMap, iOffset + nMulti * Vec_IntSum(vFanoutNums), 0 );
    Wln_NtkForEachObj( p, iObj )
    {
        Vec_IntWriteEntry( vFanoutMap, iObj, iOffset );
        iOffset += nMulti * Wln_ObjRefs(p, iObj);
    }
    assert( iOffset == Vec_IntSize(vFanoutMap) );
}

Here is the caller graph for this function:

Wln_NtkStaticFanoutStart()

void Wln_NtkStaticFanoutStart ( Wln_Ntk_t * p )

extern

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

Synopsis [Static fanout.]

Description []

SideEffects []

SeeAlso []

Definition at line 406 of file wlnNtk.c.

{
    int k, iObj, iFanin;
    Vec_Int_t * vRefsCopy = Vec_IntAlloc(0);
    Wln_NtkCreateRefs( p );
    Wln_NtkStartFanoutMap( p, &p->vFanout, &p->vRefs, 1 );
    ABC_SWAP( Vec_Int_t, *vRefsCopy, p->vRefs );
    // add fanouts
    Wln_NtkCleanRefs( p );
    Wln_NtkForEachObj( p, iObj )
        Wln_ObjForEachFanin( p, iObj, iFanin, k )
            Wln_ObjSetFanout( p, iFanin, Wln_ObjRefsInc(p, iFanin), iObj );
    // double-check the current number of fanouts added
    Wln_NtkForEachObj( p, iObj )
        assert( Wln_ObjRefs(p, iObj) == Vec_IntEntry(vRefsCopy, iObj) );
    Vec_IntFree( vRefsCopy );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkStaticFanoutStop()

void Wln_NtkStaticFanoutStop ( Wln_Ntk_t * p )

extern

Definition at line 423 of file wlnNtk.c.

{
    Vec_IntErase( &p->vRefs );
    Vec_IntErase( &p->vFanout );
}

Here is the caller graph for this function:

Wln_NtkStaticFanoutTest()

void Wln_NtkStaticFanoutTest ( Wln_Ntk_t * p )

extern

Definition at line 428 of file wlnNtk.c.

{
    int k, iObj, iFanout;
    printf( "Printing fanouts of %d objects of network \"%s\":\n", Wln_NtkObjNum(p), p->pName );
    Wln_NtkStaticFanoutStart( p );
    Wln_NtkForEachObj( p, iObj )
    {
        Wln_ObjPrint( p, iObj );
        printf( "   Fanouts : " );
        Wln_ObjForEachFanoutStatic( p, iObj, iFanout, k )
            printf( "%5d ", iFanout );
        printf( "\n" );
    }
    Wln_NtkStaticFanoutStop( p );
    printf( "\n" );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_NtkToNdr()

void * Wln_NtkToNdr ( Wln_Ntk_t * p )

extern

DECLARATIONS ///.

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

FileName [wlnNdr.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Word-level network.]

Synopsis [Constructing WLN network from NDR data structure.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - September 23, 2018.]

Revision [

Id

wlnNdr.c,v 1.00 2018/09/23 00:00:00 alanmi Exp

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file wlnNdr.c.

{
    Vec_Int_t * vFanins;
    int i, k, iObj, iFanin;
    // create a new module
    void * pDesign = Ndr_Create( 1 );
    int ModId = Ndr_AddModule( pDesign, 1 );
    // add primary inputs
    Wln_NtkForEachPi( p, iObj, i ) 
    {
        Ndr_AddObject( pDesign, ModId, ABC_OPER_CI, 0,   
            Wln_ObjRangeEnd(p, iObj), Wln_ObjRangeBeg(p, iObj), Wln_ObjIsSigned(p, iObj),   
            0, NULL,  1, &iObj,  NULL  ); // no fanins
    }
    // add internal nodes 
    vFanins = Vec_IntAlloc( 10 );
    Wln_NtkForEachObjInternal( p, iObj ) 
    {
        Vec_IntClear( vFanins );
        Wln_ObjForEachFanin( p, iObj, iFanin, k )
            Vec_IntPush( vFanins, iFanin );
        Ndr_AddObject( pDesign, ModId, Wln_ObjType(p, iObj), 0,   
            Wln_ObjRangeEnd(p, iObj), Wln_ObjRangeBeg(p, iObj), Wln_ObjIsSigned(p, iObj),   
            Vec_IntSize(vFanins), Vec_IntArray(vFanins), 1, &iObj,  
            Wln_ObjIsConst(p, iObj) ? Wln_ObjConstString(p, iObj) : NULL ); 
    }
    Vec_IntFree( vFanins );
    // add primary outputs
    Wln_NtkForEachPo( p, iObj, i ) 
    {
        Ndr_AddObject( pDesign, ModId, ABC_OPER_CO, 0,                   
            Wln_ObjRangeEnd(p, iObj), Wln_ObjRangeBeg(p, iObj), Wln_ObjIsSigned(p, iObj),   
            1, &iObj,  0, NULL,  NULL ); 
    }
    return pDesign;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_ObjAddFanin()

void Wln_ObjAddFanin ( Wln_Ntk_t * p, int iObj, int i )

extern

Definition at line 75 of file wlnObj.c.

{ 
    Wln_Vec_t * pVec = p->vFanins + iObj;
    if ( Wln_ObjFaninNum(p, iObj) < 2 )
        pVec->Array[pVec->nSize++] = i;
    else if ( Wln_ObjFaninNum(p, iObj) == 2 )
    {
        int * pArray = ABC_ALLOC( int, 4 );
        pArray[0] = pVec->Array[0];
        pArray[1] = pVec->Array[1];
        pArray[2] = i;
        pVec->pArray[0] = pArray;
        pVec->nSize     = 3;
        pVec->nCap      = 4;
    }
    else 
    {
        if ( pVec->nSize == pVec->nCap )
            pVec->pArray[0] = ABC_REALLOC( int, pVec->pArray[0], (pVec->nCap = 2*pVec->nSize) ); 
        assert( pVec->nSize < pVec->nCap );
        pVec->pArray[0][pVec->nSize++] = i;
    }
}

Here is the caller graph for this function:

Wln_ObjAddFanins()

int Wln_ObjAddFanins ( Wln_Ntk_t * p, int iObj, Vec_Int_t * vFanins )

extern

Definition at line 98 of file wlnObj.c.

{
    int i, iFanin;
    Vec_IntForEachEntry( vFanins, iFanin, i )
        Wln_ObjAddFanin( p, iObj, iFanin );
    return iObj;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_ObjAlloc()

int Wln_ObjAlloc ( Wln_Ntk_t * p, int Type, int Signed, int End, int Beg )

extern

Definition at line 105 of file wlnObj.c.

{
    int iObj = Vec_IntSize(&p->vTypes);
    if ( iObj == Vec_IntCap(&p->vTypes) )
    {
        p->vFanins = ABC_REALLOC( Wln_Vec_t, p->vFanins, 2 * iObj );
        memset( p->vFanins + iObj, 0, sizeof(Wln_Vec_t) * iObj );
        Vec_IntGrow( &p->vTypes, 2 * iObj );
    }
    assert( iObj == Vec_StrSize(&p->vSigns) );
    assert( iObj == Vec_IntSize(&p->vRanges) );
    Vec_IntPush( &p->vTypes, Type );
    Vec_StrPush( &p->vSigns, (char)Signed );
    Vec_IntPush( &p->vRanges, Hash_Int2ManInsert(p->pRanges, End, Beg, 0) );
    if ( Wln_ObjIsCi(p, iObj) ) Wln_ObjSetFanin( p, iObj, 1, Vec_IntSize(&p->vCis) ), Vec_IntPush( &p->vCis, iObj );
    if ( Wln_ObjIsCo(p, iObj) ) Wln_ObjSetFanin( p, iObj, 1, Vec_IntSize(&p->vCos) ), Vec_IntPush( &p->vCos, iObj );
    if ( Wln_ObjIsFf(p, iObj) ) Vec_IntPush( &p->vFfs, iObj );
    p->nObjs[Type]++;
    return iObj;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_ObjClone()

int Wln_ObjClone ( Wln_Ntk_t * pNew, Wln_Ntk_t * p, int iObj )

extern

Definition at line 125 of file wlnObj.c.

{
    return Wln_ObjAlloc( pNew, Wln_ObjType(p, iObj), Wln_ObjIsSigned(p, iObj), Wln_ObjRangeEnd(p, iObj), Wln_ObjRangeBeg(p, iObj) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_ObjConstString()

char * Wln_ObjConstString ( Wln_Ntk_t * p, int iObj )

extern

Definition at line 53 of file wlnObj.c.

{
    assert( Wln_ObjIsConst(p, iObj) );
    return Abc_NamStr( p->pManName, Wln_ObjFanin0(p, iObj) );
}                          

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_ObjCreateCo()

int Wln_ObjCreateCo ( Wln_Ntk_t * p, int iFanin )

extern

Definition at line 129 of file wlnObj.c.

{
    int iCo = Wln_ObjClone( p, p, iFanin );
    Wln_ObjUpdateType( p, iCo, ABC_OPER_CO );
    Wln_ObjAddFanin( p, iCo, iFanin );
    return iCo;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_ObjName()

char * Wln_ObjName ( Wln_Ntk_t * p, int iObj )

extern

DECLARATIONS ///.

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

FileName [wlnObj.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Word-level network.]

Synopsis [Object construction procedures.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - September 23, 2018.]

Revision [

Id

wlnObj.c,v 1.00 2018/09/23 00:00:00 alanmi Exp

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

Synopsis [Creating objects.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file wlnObj.c.

{
    static char Buffer[100];
    if ( Wln_NtkHasNameId(p) && Wln_ObjNameId(p, iObj) )
        return Abc_NamStr( p->pManName, Wln_ObjNameId(p, iObj) );
    sprintf( Buffer, "n%d", iObj );
    return Buffer;
}                          

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_ObjPrint()

void Wln_ObjPrint ( Wln_Ntk_t * p, int iObj )

extern

Definition at line 136 of file wlnObj.c.

{
    int k, iFanin, Type = Wln_ObjType(p, iObj);
    printf( "Obj %6d : Type = %6s  Fanins = %d : ", iObj, Abc_OperName(Type), Wln_ObjFaninNum(p, iObj) );
    Wln_ObjForEachFanin( p, iObj, iFanin, k )
        printf( "%5d ", iFanin );
    printf( "\n" );
}

Here is the caller graph for this function:

Wln_ObjSetConst()

void Wln_ObjSetConst ( Wln_Ntk_t * p, int iObj, int NameId )

extern

Definition at line 65 of file wlnObj.c.

{
    assert( Wln_ObjIsConst(p, iObj) );
    Wln_ObjSetFanin( p, iObj, 0, NameId );
}

Here is the caller graph for this function:

Wln_ObjSetSlice()

void Wln_ObjSetSlice ( Wln_Ntk_t * p, int iObj, int SliceId )

extern

Definition at line 70 of file wlnObj.c.

{
    assert( Wln_ObjIsSlice(p, iObj) );
    Wln_ObjSetFanin( p, iObj, 1, SliceId );
}

Here is the caller graph for this function:

Wln_ObjUpdateType()

void Wln_ObjUpdateType ( Wln_Ntk_t * p, int iObj, int Type )

extern

Definition at line 58 of file wlnObj.c.

{
    assert( Wln_ObjIsNone(p, iObj) );
    p->nObjs[Wln_ObjType(p, iObj)]--;
    Vec_IntWriteEntry( &p->vTypes, iObj, Type );
    p->nObjs[Wln_ObjType(p, iObj)]++;
}

Here is the caller graph for this function:

Wln_ReadNdr()

Wln_Ntk_t * Wln_ReadNdr ( char * pFileName )

extern

FUNCTION DECLARATIONS ///.

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 298 of file wlnNdr.c.

{
    void * pData = Ndr_Read( pFileName );
    Wln_Ntk_t * pNtk = pData ? Wln_NtkFromNdr( pData, 0 ) : NULL;
    if ( pNtk ) return NULL;
    //char * ppNames[10] = { NULL, "a", "b", "c", "d", "e", "f", "g", "h", "i" };
    //Ndr_WriteVerilog( NULL, pData, ppNames, 0 );
    Ndr_Delete( pData );
    return pNtk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Wln_WriteNdr()

void Wln_WriteNdr ( Wln_Ntk_t * pNtk, char * pFileName )

extern

Definition at line 81 of file wlnNdr.c.

{
    void * pDesign = Wln_NtkToNdr( p );
    Ndr_Write( pFileName, pDesign );
    Ndr_Delete( pDesign );
    printf( "Dumped the current design into file \"%s\".\n", pFileName );
}

Here is the call graph for this function:

Wln_WriteVer()

void Wln_WriteVer ( Wln_Ntk_t * p, char * pFileName )

extern

Definition at line 478 of file wlnWriteVer.c.

{
    FILE * pFile;
    pFile = fopen( pFileName, "w" );
    if ( pFile == NULL )
    {
        fprintf( stdout, "Wln_WriteVer(): Cannot open the output file \"%s\".\n", pFileName );
        return;
    }
    fprintf( pFile, "// Benchmark \"%s\" from file \"%s\" written by ABC on %s\n", p->pName, p->pSpec ? p->pSpec : "unknown", Extra_TimeStamp() );
    fprintf( pFile, "\n" );
    Wln_WriteTables( pFile, p );
//    if ( fAddCos )
//        Wln_WriteAddPos( p );
    Wln_WriteVerInt( pFile, p );
    fprintf( pFile, "\n" );
    fclose( pFile );
}

Here is the call graph for this function:

Here is the caller graph for this function: