#include "bac.h"

Include dependency graph for bacNtk.c:

Classes
struct	Bac_Pair_t_

Typedefs
typedef typedefABC_NAMESPACE_IMPL_START struct Bac_Pair_t_	Bac_Pair_t
	DECLARATIONS ///.

Functions
void	Bac_ManSetupTypes (char pNames, char pSymbs)

char *	Bac_NtkGenerateName (Bac_Ntk_t p, Bac_ObjType_t Type, Vec_Int_t vBits)

Bac_ObjType_t	Bac_NameToType (char *pName)

Vec_Int_t *	Bac_NameToRanges (char *pName)

void	Bac_NtkUpdateFanout (Bac_Ntk_t *p, int iOld, int iNew)
	FUNCTION DEFINITIONS ///.

void	Bac_NtkDeriveFanout (Bac_Ntk_t *p)

void	Bac_ManDeriveFanout (Bac_Man_t *p)

int	Bac_ManAssignInternTwo (Bac_Ntk_t p, int iNum, int nDigits, char pPref, Vec_Int_t *vMap)

int	Bac_ManAssignCountNames (Bac_Ntk_t *p)

void	Bac_ManAssignInternWordNamesNtk (Bac_Ntk_t p, Vec_Int_t vMap)

void	Bac_ManAssignInternWordNames (Bac_Man_t *p)

int	Bac_ManClpObjNum_rec (Bac_Ntk_t *p)

int	Bac_ManClpObjNum (Bac_Man_t *p)

void	Bac_NtkDfs_rec (Bac_Ntk_t p, int iObj, Vec_Int_t vBoxes)

Vec_Int_t *	Bac_NtkDfs (Bac_Ntk_t *p)

int	Bac_NtkDfsUserBoxes_rec (Bac_Ntk_t p, int iObj, Vec_Int_t vBoxes)

int	Bac_NtkDfsUserBoxes (Bac_Ntk_t *p)

void	Bac_NtkCollapse_rec (Bac_Ntk_t pNew, Bac_Ntk_t p, Vec_Int_t *vSigs)

Bac_Man_t *	Bac_ManCollapse (Bac_Man_t *p)

Typedef Documentation

◆ Bac_Pair_t

typedef typedefABC_NAMESPACE_IMPL_START struct Bac_Pair_t_ Bac_Pair_t

DECLARATIONS ///.

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

FileName [bacNtk.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Hierarchical word-level netlist.]

Synopsis [Netlist manipulation.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

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

]

Definition at line 29 of file bacNtk.c.

Function Documentation

◆ Bac_ManAssignCountNames()

int Bac_ManAssignCountNames ( Bac_Ntk_t * p )

Definition at line 290 of file bacNtk.c.

{
    int i, iObj, iBox, Count = 0;
    Bac_NtkForEachPiMain( p, iObj, i )
        if ( !Bac_ObjNameInt(p, iObj) )
            Count++;
    Bac_NtkForEachBox( p, iBox )
        Bac_BoxForEachBoMain( p, iBox, iObj, i )
            if ( !Bac_ObjNameInt(p, iObj) )
                Count++;
    return Count;
}

Here is the caller graph for this function:

◆ Bac_ManAssignInternTwo()

int Bac_ManAssignInternTwo	(	Bac_Ntk_t *	p,
		int	iNum,
		int	nDigits,
		char *	pPref,
		Vec_Int_t *	vMap )

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

Synopsis [Assigns word-level names.]

Description []

SideEffects []

SeeAlso []

Definition at line 276 of file bacNtk.c.

{
    char Buffer[16]; int i, NameId = 0;
    for ( i = 0; !NameId || Vec_IntEntry(vMap, NameId); i++ )
    {
        if ( i == 0 )
            sprintf( Buffer, "%s%0*d", pPref, nDigits, iNum );
        else
            sprintf( Buffer, "%s%0*d_%d", pPref, nDigits, iNum, i );
        NameId = Abc_NamStrFindOrAdd( p->pDesign->pStrs, Buffer, NULL );
    }
    Vec_IntWriteEntry( vMap, NameId, 1 );
    return NameId;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Bac_ManAssignInternWordNames()

void Bac_ManAssignInternWordNames ( Bac_Man_t * p )

Definition at line 392 of file bacNtk.c.

{
    Vec_Int_t * vMap = Vec_IntStart( 2*Bac_ManObjNum(p) );
    Bac_Ntk_t * pNtk; int i;
    Bac_ManForEachNtk( p, pNtk, i )
        Bac_ManAssignInternWordNamesNtk( pNtk, vMap );
    assert( Vec_IntCountEntry(vMap, 0) == Vec_IntSize(vMap) );
    Vec_IntFree( vMap );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Bac_ManAssignInternWordNamesNtk()

void Bac_ManAssignInternWordNamesNtk	(	Bac_Ntk_t *	p,
		Vec_Int_t *	vMap )

Definition at line 302 of file bacNtk.c.

{
    int k, iObj, iTerm, iName = -1, iBit = -1;
    int nDigits, nPis = 0, nPos = 0, nNames = 1;
    // start names
    if ( !Bac_NtkHasNames(p) )
        Bac_NtkStartNames(p);
    nDigits = Abc_Base10Log( Bac_ManAssignCountNames(p) );
    // populate map with the currently used names
    Bac_NtkForEachCi( p, iObj )
        if ( Bac_ObjNameInt(p, iObj) )
            Vec_IntWriteEntry( vMap, Bac_ObjNameId(p, iObj), 1 );
    Bac_NtkForEachBox( p, iObj )
        if ( Bac_ObjNameInt(p, iObj) )
            Vec_IntWriteEntry( vMap, Bac_ObjNameId(p, iObj), 1 );
    // assign CI names
    Bac_NtkForEachCi( p, iObj )
    {
        if ( Bac_ObjNameInt(p, iObj) )
        {
            iName = -1;
            iBit = -1;
            continue;
        }
        if ( Bac_ObjBit(p, iObj) )
        {
            assert( iBit > 0 );
            Bac_ObjSetName( p, iObj, Abc_Var2Lit2(iBit++, BAC_NAME_INDEX) );
        }
        else
        {
            //int Type = Bac_ObjType(p, iObj);
            int Range = Bac_ObjIsPi(p, iObj) ? Bac_ObjPiRange(p, iObj) : Bac_BoxBoRange(p, iObj);
            iName = Bac_ManAssignInternTwo( p, nNames++, nDigits, (char*)(Bac_ObjIsPi(p, iObj) ? "i":"n"), vMap );
            if ( Range == 1 )
                Bac_ObjSetName( p, iObj, Abc_Var2Lit2(iName, BAC_NAME_BIN) );
            else
                Bac_ObjSetName( p, iObj, Abc_Var2Lit2(iName, BAC_NAME_WORD) );
            iBit = 1;
        }
    }
    // transfer names to the interface
    if ( Bac_NtkInfoNum(p) )
    {
        for ( k = 0; k < Bac_NtkInfoNum(p); k++ )
        {
            //char * pName = Bac_NtkName(p);
            if ( Bac_NtkInfoType(p, k) == 1 ) // PI
            {
                iObj = Bac_NtkPi(p, nPis);
                assert( !Bac_ObjBit(p, iObj) );
                assert( Bac_ObjNameType(p, iObj) <= BAC_NAME_WORD );
                Bac_NtkSetInfoName( p, k, Abc_Var2Lit2(Bac_ObjNameId(p, iObj), 1) );
                nPis += Bac_NtkInfoRange(p, k);
            }
            else if ( Bac_NtkInfoType(p, k) == 2 ) // PO
            {
                iObj = Bac_NtkPo(p, nPos);
                assert( !Bac_ObjBit(p, iObj) );
                iObj = Bac_ObjFanin(p, iObj);
                assert( Bac_ObjNameType(p, iObj) <= BAC_NAME_WORD );
                Bac_NtkSetInfoName( p, k, Abc_Var2Lit2(Bac_ObjNameId(p, iObj), 2) );
                nPos += Bac_NtkInfoRange(p, k);
            }
            else assert( 0 );
        }
        assert( nPis == Bac_NtkPiNum(p) );
        assert( nPos == Bac_NtkPoNum(p) );
    }
    // assign instance names
    nDigits = Abc_Base10Log( Bac_NtkObjNum(p) );
    Bac_NtkForEachBox( p, iObj )
        if ( !Bac_ObjNameInt(p, iObj) )
        {
            iName = Bac_ManAssignInternTwo( p, iObj, nDigits, "g", vMap );
            Bac_ObjSetName( p, iObj, Abc_Var2Lit2(iName, BAC_NAME_BIN) );
        }
    // unmark all names
    Bac_NtkForEachPi( p, iObj, k )
        if ( Bac_ObjNameType(p, iObj) <= BAC_NAME_WORD )
            Vec_IntWriteEntry( vMap, Bac_ObjNameId(p, iObj), 0 );
    Bac_NtkForEachBox( p, iObj )
    {
        Vec_IntWriteEntry( vMap, Bac_ObjNameId(p, iObj), 0 );
        Bac_BoxForEachBo( p, iObj, iTerm, k )
            if ( Bac_ObjNameType(p, iTerm) <= BAC_NAME_WORD )
                Vec_IntWriteEntry( vMap, Bac_ObjNameId(p, iTerm), 0 );
    }
//    printf( "Generated %d word-level names.\n", nNames-1 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Bac_ManClpObjNum()

int Bac_ManClpObjNum ( Bac_Man_t * p )

Definition at line 423 of file bacNtk.c.

{
    Bac_Ntk_t * pNtk; int i;
    Bac_ManForEachNtk( p, pNtk, i )
        pNtk->Count = -1;
    return Bac_NtkPioNum( Bac_ManRoot(p) ) + Bac_ManClpObjNum_rec( Bac_ManRoot(p) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Bac_ManClpObjNum_rec()

int Bac_ManClpObjNum_rec ( Bac_Ntk_t * p )

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

Synopsis [Count number of objects after collapsing.]

Description []

SideEffects []

SeeAlso []

Definition at line 414 of file bacNtk.c.

{
    int i, Counter = 0;
    if ( p->Count >= 0 )
        return p->Count;
    Bac_NtkForEachBox( p, i )
        Counter += Bac_ObjIsBoxUser(p, i) ? Bac_ManClpObjNum_rec( Bac_BoxNtk(p, i) ) + 3*Bac_BoxBoNum(p, i) : Bac_BoxSize(p, i);
    return (p->Count = Counter);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Bac_ManCollapse()

Bac_Man_t * Bac_ManCollapse ( Bac_Man_t * p )

Definition at line 567 of file bacNtk.c.

{
    int i, iObj;
    Vec_Int_t * vSigs = Vec_IntAlloc( 1000 );
    Bac_Man_t * pNew = Bac_ManStart( p, 1 );
    Bac_Ntk_t * pRoot = Bac_ManRoot( p );
    Bac_Ntk_t * pRootNew = Bac_ManRoot( pNew );
    Bac_NtkAlloc( pRootNew, Bac_NtkNameId(pRoot), Bac_NtkPiNum(pRoot), Bac_NtkPoNum(pRoot), Bac_ManClpObjNum(p) );
    if ( Vec_IntSize(&pRoot->vInfo) )
        Vec_IntAppend( &pRootNew->vInfo, &pRoot->vInfo );
    Bac_NtkForEachPi( pRoot, iObj, i )
        Vec_IntPush( vSigs, Bac_ObjAlloc(pRootNew, BAC_OBJ_PI, -1) );
    Bac_NtkCollapse_rec( pRootNew, pRoot, vSigs );
    assert( Vec_IntSize(vSigs) == Bac_NtkPoNum(pRoot) );
    Bac_NtkForEachPo( pRoot, iObj, i )
        Bac_ObjAlloc( pRootNew, BAC_OBJ_PO, Vec_IntEntry(vSigs, i) );
    assert( Bac_NtkObjNum(pRootNew) == Bac_NtkObjNumAlloc(pRootNew) );
    Vec_IntFree( vSigs );
    // transfer PI/PO names
    if ( Bac_NtkHasNames(pRoot) )
    {
        Bac_NtkStartNames( pRootNew );
        Bac_NtkForEachPi( pRoot, iObj, i )
            Bac_ObjSetName( pRootNew, Bac_NtkPi(pRootNew, i), Bac_ObjName(pRoot, iObj) );
        Bac_NtkForEachPoDriver( pRoot, iObj, i )
            if ( !Bac_ObjIsPi(pRoot, iObj) )
                Bac_ObjSetName( pRootNew, Bac_ObjCopy(pRoot, iObj), Bac_ObjName(pRoot, iObj) );
    }
    return pNew;
}

Here is the call graph for this function:

◆ Bac_ManDeriveFanout()

void Bac_ManDeriveFanout ( Bac_Man_t * p )

Definition at line 258 of file bacNtk.c.

{
    Bac_Ntk_t * pNtk; int i;
    Bac_ManForEachNtk( p, pNtk, i )
        Bac_NtkDeriveFanout( pNtk );
}

Here is the call graph for this function:

◆ Bac_ManSetupTypes()

void Bac_ManSetupTypes	(	char **	pNames,
		char **	pSymbs )

Definition at line 131 of file bacNtk.c.

{
    int Type;
    for ( Type = 1; Type < BAC_BOX_UNKNOWN; Type++ )
    {
        int Id = Bac_GetTypeId( (Bac_ObjType_t)Type );
        pNames[Type] = s_Types[Id].pName;
        pSymbs[Type] = s_Types[Id].pSymb;
    }
}

◆ Bac_NameToRanges()

Vec_Int_t * Bac_NameToRanges ( char * pName )

Definition at line 172 of file bacNtk.c.

{
    static Vec_Int_t Bits, * vBits = &Bits;
    static int pArray[10];
    char * pTemp; 
    int Num = 0, Count = 0;
    // initialize array
    vBits->pArray = pArray;
    vBits->nSize = 0;
    vBits->nCap = 10;
    // check the name
    assert( !strncmp(pName, s_Pref, strlen(s_Pref)) );
    for ( pTemp = pName; *pTemp && !Bac_CharIsDigit(*pTemp); pTemp++ );
    assert( Bac_CharIsDigit(*pTemp) );
    for ( ; *pTemp; pTemp++ )
    {
        if ( Bac_CharIsDigit(*pTemp) )
            Num = 10 * Num + *pTemp - '0';
        else
            Vec_IntPush( vBits, Num ), Count += Num, Num = 0;
    }
    assert( Num > 0 );
    Vec_IntPush( vBits, Num );  Count += Num;
    assert( Vec_IntSize(vBits) <= 10 );
    return vBits;
}

Here is the call graph for this function:

◆ Bac_NameToType()

Bac_ObjType_t Bac_NameToType ( char * pName )

Definition at line 161 of file bacNtk.c.

{
    int i;
    if ( strncmp(pName, s_Pref, strlen(s_Pref)) )
        return BAC_OBJ_NONE;
    pName += strlen(s_Pref);
    for ( i = 1; i < BAC_BOX_UNKNOWN; i++ )
        if ( !strncmp(pName, s_Types[i].pName, strlen(s_Types[i].pName)) )
            return s_Types[i].Type;
    return BAC_OBJ_NONE;
}

Here is the call graph for this function:

◆ Bac_NtkCollapse_rec()

void Bac_NtkCollapse_rec	(	Bac_Ntk_t *	pNew,
		Bac_Ntk_t *	p,
		Vec_Int_t *	vSigs )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 523 of file bacNtk.c.

{
    int i, iObj, iObjNew, iTerm;
    Bac_NtkStartCopies( p );
    // set PI copies
    assert( Vec_IntSize(vSigs) == Bac_NtkPiNum(p) );
    Bac_NtkForEachPi( p, iObj, i )
        Bac_ObjSetCopy( p, iObj, Vec_IntEntry(vSigs, i) );
    // duplicate internal objects and create buffers for hierarchy instances
    Bac_NtkForEachBox( p, iObj )
        if ( Bac_ObjIsBoxPrim( p, iObj ) )
            Bac_BoxDup( pNew, p, iObj );
        else
        {
            Bac_BoxForEachBo( p, iObj, iTerm, i )
            {
                iObjNew = Bac_ObjAlloc( pNew, BAC_OBJ_BI,  -1 );
                iObjNew = Bac_ObjAlloc( pNew, BAC_BOX_BUF, -1 ); // buffer
                iObjNew = Bac_ObjAlloc( pNew, BAC_OBJ_BO,  -1 );
                Bac_ObjSetCopy( p, iTerm, iObjNew );
            }
        }
    // duplicate user modules and connect objects
    Bac_NtkForEachBox( p, iObj )
        if ( Bac_ObjIsBoxPrim( p, iObj ) )
        {
            Bac_BoxForEachBi( p, iObj, iTerm, i )
                Bac_ObjSetFanin( pNew, Bac_ObjCopy(p, iTerm), Bac_ObjCopy(p, Bac_ObjFanin(p, iTerm)) );
        }
        else
        {
            Vec_IntClear( vSigs );
            Bac_BoxForEachBi( p, iObj, iTerm, i )
                Vec_IntPush( vSigs, Bac_ObjCopy(p, Bac_ObjFanin(p, iTerm)) );
            Bac_NtkCollapse_rec( pNew, Bac_BoxNtk(p, iObj), vSigs );
            assert( Vec_IntSize(vSigs) == Bac_BoxBoNum(p, iObj) );
            Bac_BoxForEachBo( p, iObj, iTerm, i )
                Bac_ObjSetFanin( pNew, Bac_ObjCopy(p, iTerm)-2, Vec_IntEntry(vSigs, i) );
        }
    // collect POs
    Vec_IntClear( vSigs );
    Bac_NtkForEachPo( p, iObj, i )
        Vec_IntPush( vSigs, Bac_ObjCopy(p, Bac_ObjFanin(p, iObj)) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Bac_NtkDeriveFanout()

void Bac_NtkDeriveFanout ( Bac_Ntk_t * p )

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

Synopsis [Derives fanout.]

Description []

SideEffects []

SeeAlso []

Definition at line 241 of file bacNtk.c.

{
    int iCi, iCo;
    assert( !Bac_NtkHasFanouts(p) );
    Bac_NtkStartFanouts( p );
    Bac_NtkForEachCo( p, iCo )
    {
        assert( !Bac_ObjNextFanout(p, iCo) );
        iCi = Bac_ObjFanin(p, iCo);
        if ( Bac_ObjFanout(p, iCi) )
            Bac_ObjSetNextFanout( p, Bac_ObjFanout(p, iCi), iCo );
        Bac_ObjSetFanout( p, iCi, iCo );
    }
    Bac_NtkForEachCo( p, iCo )
        if ( !Bac_ObjNextFanout(p, iCo) )
            Bac_ObjSetFanout( p, Bac_ObjFanin(p, iCo), iCo );
}

Here is the caller graph for this function:

◆ Bac_NtkDfs()

Vec_Int_t * Bac_NtkDfs ( Bac_Ntk_t * p )

Definition at line 458 of file bacNtk.c.

{
    int i, iObj;
    Vec_Int_t * vBoxes = Vec_IntAlloc( Bac_NtkBoxNum(p) );
    Bac_NtkStartCopies( p ); // -1 = not visited; 1 = finished
    Bac_NtkForEachPi( p, iObj, i )
        Bac_ObjSetCopy( p, iObj, 1 );
    Bac_NtkForEachPo( p, iObj, i )
        Bac_NtkDfs_rec( p, Bac_ObjFanin(p, iObj), vBoxes );
    return vBoxes;
}

Here is the call graph for this function:

◆ Bac_NtkDfs_rec()

void Bac_NtkDfs_rec	(	Bac_Ntk_t *	p,
		int	iObj,
		Vec_Int_t *	vBoxes )

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

Synopsis [Collects boxes in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 442 of file bacNtk.c.

{
    int k, iFanin;
    if ( Bac_ObjIsBo(p, iObj) == 1 )
    {
        Bac_NtkDfs_rec( p, Bac_ObjFanin(p, iObj), vBoxes );
        return;
    }
    assert( Bac_ObjIsPi(p, iObj) || Bac_ObjIsBox(p, iObj) );
    if ( Bac_ObjCopy(p, iObj) > 0 ) // visited
        return;
    Bac_ObjSetCopy( p, iObj, 1 );
    Bac_BoxForEachFanin( p, iObj, iFanin, k )
        Bac_NtkDfs_rec( p, iFanin, vBoxes );
    Vec_IntPush( vBoxes, iObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Bac_NtkDfsUserBoxes()

int Bac_NtkDfsUserBoxes ( Bac_Ntk_t * p )

Definition at line 498 of file bacNtk.c.

{
    int iObj;
    Bac_NtkStartCopies( p ); // -1 = not visited; 0 = on the path; 1 = finished
    Vec_IntClear( &p->vArray );
    Bac_NtkForEachBoxUser( p, iObj )
        if ( !Bac_NtkDfsUserBoxes_rec( p, iObj, &p->vArray ) )
        {
            printf( "Cyclic dependency of user boxes is detected.\n" );
            return 0;
        }
    return 1;
}

Here is the call graph for this function:

◆ Bac_NtkDfsUserBoxes_rec()

int Bac_NtkDfsUserBoxes_rec	(	Bac_Ntk_t *	p,
		int	iObj,
		Vec_Int_t *	vBoxes )

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

Synopsis [Collects user boxes in the DFS order.]

Description []

SideEffects []

SeeAlso []

Definition at line 481 of file bacNtk.c.

{
    int k, iFanin;
    assert( Bac_ObjIsBoxUser(p, iObj) );
    if ( Bac_ObjCopy(p, iObj) == 1 ) // visited
        return 1;
    if ( Bac_ObjCopy(p, iObj) == 0 ) // loop
        return 0;
    Bac_ObjSetCopy( p, iObj, 0 );
    Bac_BoxForEachFanin( p, iObj, iFanin, k )
        if ( Bac_ObjIsBo(p, iFanin) && Bac_ObjIsBoxUser(p, Bac_ObjFanin(p, iFanin)) )
            if ( !Bac_NtkDfsUserBoxes_rec( p, Bac_ObjFanin(p, iFanin), vBoxes ) )
                return 0;
    Vec_IntPush( vBoxes, iObj );
    Bac_ObjSetCopy( p, iObj, 1 );
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Bac_NtkGenerateName()

char * Bac_NtkGenerateName	(	Bac_Ntk_t *	p,
		Bac_ObjType_t	Type,
		Vec_Int_t *	vBits )

Definition at line 142 of file bacNtk.c.

{
    static char Buffer[100]; 
    char * pTemp; int i, Bits;
    char * pName = Bac_ManPrimName( p->pDesign, Type );
    char * pSymb = Bac_ManPrimSymb( p->pDesign, Type );
    assert( Vec_IntSize(vBits) == (int)strlen(pSymb) );
    sprintf( Buffer, "%s%s_", s_Pref, pName );
    pTemp = Buffer + strlen(Buffer);
    Vec_IntForEachEntry( vBits, Bits, i )
    {
        sprintf( pTemp, "%c%d", pSymb[i], Bits );
        pTemp += strlen(pTemp);
    }
    //Vec_IntPrint( vBits );
    //printf( "%s\n", Buffer );
    return Buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Bac_NtkUpdateFanout()

void Bac_NtkUpdateFanout	(	Bac_Ntk_t *	p,
		int	iOld,
		int	iNew )

FUNCTION DEFINITIONS ///.

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

Synopsis [Replaces fanin iOld by iNew in all fanouts.]

Description []

SideEffects []

SeeAlso []

Definition at line 215 of file bacNtk.c.

{
    int iCo;
    assert( Bac_ObjIsCi(p, iOld) );
    assert( Bac_ObjIsCi(p, iNew) );
    Bac_ObjForEachFanout( p, iOld, iCo )
    {
        assert( Bac_ObjFanin(p, iCo) == iOld );
        Bac_ObjCleanFanin( p, iCo );
        Bac_ObjSetFanin( p, iCo, iNew );
    }
    Bac_ObjSetFanout( p, iNew, Bac_ObjFanout(p, iOld) );
    Bac_ObjSetFanout( p, iOld, 0 );
}

Classes

Typedefs

Functions

Typedef Documentation

◆ Bac_Pair_t

Function Documentation

◆ Bac_ManAssignCountNames()

◆ Bac_ManAssignInternTwo()

◆ Bac_ManAssignInternWordNames()

◆ Bac_ManAssignInternWordNamesNtk()

◆ Bac_ManClpObjNum()

◆ Bac_ManClpObjNum_rec()

◆ Bac_ManCollapse()

◆ Bac_ManDeriveFanout()

◆ Bac_ManSetupTypes()

◆ Bac_NameToRanges()

◆ Bac_NameToType()

◆ Bac_NtkCollapse_rec()

◆ Bac_NtkDeriveFanout()

◆ Bac_NtkDfs()

◆ Bac_NtkDfs_rec()

◆ Bac_NtkDfsUserBoxes()

◆ Bac_NtkDfsUserBoxes_rec()

◆ Bac_NtkGenerateName()

◆ Bac_NtkUpdateFanout()