mio.h File Reference

Go to the source code of this file.

Data Structures
struct	Mio_Cell_t_

Macros
#define	Mio_LibraryForEachGate(Lib, Gate)
	GLOBAL VARIABLES ///. More...
#define	Mio_LibraryForEachGateSafe(Lib, Gate, Gate2)
#define	Mio_GateForEachPin(Gate, Pin)
#define	Mio_GateForEachPinSafe(Gate, Pin, Pin2)

Typedefs
typedef struct Mio_LibraryStruct_t_	Mio_Library_t
typedef struct Mio_GateStruct_t_	Mio_Gate_t
typedef struct Mio_PinStruct_t_	Mio_Pin_t
typedef struct Mio_Cell_t_	Mio_Cell_t

Enumerations
enum	Mio_PinPhase_t { MIO_PHASE_UNKNOWN, MIO_PHASE_INV, MIO_PHASE_NONINV }
	INCLUDES ///. More...

Functions
void	Mio_UpdateGenlib (Mio_Library_t *pLib)
	FUNCTION DEFINITIONS ///. More...
int	Mio_UpdateGenlib2 (Vec_Str_t *vStr, Vec_Str_t *vStr2, char *pFileName, int fVerbose)
char *	Mio_LibraryReadName (Mio_Library_t *pLib)
	DECLARATIONS ///. More...
int	Mio_LibraryReadGateNum (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadGates (Mio_Library_t *pLib)
Mio_Gate_t **	Mio_LibraryReadGateArray (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadGateByName (Mio_Library_t *pLib, char *pName, char *pOutName)
char *	Mio_LibraryReadSopByName (Mio_Library_t *pLib, char *pName)
Mio_Gate_t *	Mio_LibraryReadConst0 (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadConst1 (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadNand2 (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadAnd2 (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadBuf (Mio_Library_t *pLib)
Mio_Gate_t *	Mio_LibraryReadInv (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayInvRise (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayInvFall (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayInvMax (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayNand2Rise (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayNand2Fall (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayNand2Max (Mio_Library_t *pLib)
float	Mio_LibraryReadDelayAnd2Max (Mio_Library_t *pLib)
float	Mio_LibraryReadAreaInv (Mio_Library_t *pLib)
float	Mio_LibraryReadAreaBuf (Mio_Library_t *pLib)
float	Mio_LibraryReadAreaNand2 (Mio_Library_t *pLib)
int	Mio_LibraryReadGateNameMax (Mio_Library_t *pLib)
char *	Mio_GateReadName (Mio_Gate_t *pGate)
char *	Mio_GateReadOutName (Mio_Gate_t *pGate)
double	Mio_GateReadArea (Mio_Gate_t *pGate)
char *	Mio_GateReadForm (Mio_Gate_t *pGate)
Mio_Pin_t *	Mio_GateReadPins (Mio_Gate_t *pGate)
Mio_Library_t *	Mio_GateReadLib (Mio_Gate_t *pGate)
Mio_Gate_t *	Mio_GateReadNext (Mio_Gate_t *pGate)
Mio_Gate_t *	Mio_GateReadTwin (Mio_Gate_t *pGate)
int	Mio_GateReadPinNum (Mio_Gate_t *pGate)
double	Mio_GateReadDelayMax (Mio_Gate_t *pGate)
char *	Mio_GateReadSop (Mio_Gate_t *pGate)
word	Mio_GateReadTruth (Mio_Gate_t *pGate)
int	Mio_GateReadValue (Mio_Gate_t *pGate)
char *	Mio_GateReadPinName (Mio_Gate_t *pGate, int iPin)
float	Mio_GateReadPinDelay (Mio_Gate_t *pGate, int iPin)
void	Mio_GateSetValue (Mio_Gate_t *pGate, int Value)
char *	Mio_PinReadName (Mio_Pin_t *pPin)
Mio_PinPhase_t	Mio_PinReadPhase (Mio_Pin_t *pPin)
double	Mio_PinReadInputLoad (Mio_Pin_t *pPin)
double	Mio_PinReadMaxLoad (Mio_Pin_t *pPin)
double	Mio_PinReadDelayBlockRise (Mio_Pin_t *pPin)
double	Mio_PinReadDelayFanoutRise (Mio_Pin_t *pPin)
double	Mio_PinReadDelayBlockFall (Mio_Pin_t *pPin)
double	Mio_PinReadDelayFanoutFall (Mio_Pin_t *pPin)
double	Mio_PinReadDelayBlockMax (Mio_Pin_t *pPin)
Mio_Pin_t *	Mio_PinReadNext (Mio_Pin_t *pPin)
char *	Mio_ReadFile (char *FileName, int fAddEnd)
Mio_Library_t *	Mio_LibraryRead (char *FileName, char *pBuffer, char *ExcludeFile, int fVerbose)
int	Mio_LibraryReadExclude (char *ExcludeFile, st__table *tExcludeGate)
int	Mio_LibraryParseFormulas (Mio_Library_t *pLib)
	FUNCTION DEFINITIONS ///. More...
Vec_Int_t *	Mio_ParseFormula (char *pFormInit, char **ppVarNames, int nVars)
Vec_Wrd_t *	Mio_ParseFormulaTruth (char *pFormInit, char **ppVarNames, int nVars)
int	Mio_ParseCheckFormula (Mio_Gate_t *pGate, char *pForm)
char *	Mio_LibDeriveSop (int nVars, Vec_Int_t *vExpr, Vec_Str_t *vStr)
void	Mio_LibraryDelete (Mio_Library_t *pLib)
	DECLARATIONS ///. More...
void	Mio_GateDelete (Mio_Gate_t *pGate)
void	Mio_PinDelete (Mio_Pin_t *pPin)
Mio_Pin_t *	Mio_PinDup (Mio_Pin_t *pPin)
void	Mio_WriteLibrary (FILE *pFile, Mio_Library_t *pLib, int fPrintSops)
Mio_Gate_t **	Mio_CollectRoots (Mio_Library_t *pLib, int nInputs, float tDelay, int fSkipInv, int *pnGates, int fVerbose)
Mio_Cell_t *	Mio_CollectRootsNew (Mio_Library_t *pLib, int nInputs, int *pnGates, int fVerbose)
Mio_Cell_t *	Mio_CollectRootsNewDefault (int nInputs, int *pnGates, int fVerbose)
word	Mio_DeriveTruthTable6 (Mio_Gate_t *pGate)
void	Mio_DeriveTruthTable (Mio_Gate_t *pGate, unsigned uTruthsIn[][2], int nSigns, int nInputs, unsigned uTruthRes[])
void	Mio_DeriveGateDelays (Mio_Gate_t *pGate, float **ptPinDelays, int nPins, int nInputs, float tDelayZero, float *ptDelaysRes, float *ptPinDelayMax)
Mio_Gate_t *	Mio_GateCreatePseudo (int nInputs)
void	Mio_LibraryShiftDelay (Mio_Library_t *pLib, double Shift)
void	Mio_LibraryMultiArea (Mio_Library_t *pLib, double Multi)
void	Mio_LibraryMultiDelay (Mio_Library_t *pLib, double Multi)
void	Mio_LibraryTransferDelays (Mio_Library_t *pLibD, Mio_Library_t *pLibS)
Mio_Library_t *	Abc_SclDeriveGenlibSimple (void *pScl)
Mio_Library_t *	Abc_SclDeriveGenlib (void *pScl, float Slew, float Gain, int nGatesMin, int fVerbose)
int	Abc_SclHasDelayInfo (void *pScl)

Macro Definition Documentation

#define Mio_GateForEachPin	(		Gate,
			Pin
	)

Value:

for ( Pin = Mio_GateReadPins(Gate);                       \
          Pin;                                                \
          Pin = Mio_PinReadNext(Pin) )

Definition at line 76 of file mio.h.

#define Mio_GateForEachPinSafe	(		Gate,
			Pin,
			Pin2
	)

Value:

for ( Pin = Mio_GateReadPins(Gate),                       \
          Pin2 = (Pin? Mio_PinReadNext(Pin): NULL);           \
          Pin;                                                \
          Pin = Pin2,                                         \
          Pin2 = (Pin? Mio_PinReadNext(Pin): NULL) )

Definition at line 80 of file mio.h.

#define Mio_LibraryForEachGate	(		Lib,
			Gate
	)

Value:

for ( Gate = Mio_LibraryReadGates(Lib);                   \
          Gate;                                               \
          Gate = Mio_GateReadNext(Gate) )

GLOBAL VARIABLES ///.

MACRO DEFINITIONS ///

Definition at line 65 of file mio.h.

#define Mio_LibraryForEachGateSafe	(		Lib,
			Gate,
			Gate2
	)

Value:

for ( Gate = Mio_LibraryReadGates(Lib),                   \
          Gate2 = (Gate? Mio_GateReadNext(Gate): NULL);       \
          Gate;                                               \
          Gate = Gate2,                                       \
          Gate2 = (Gate? Mio_GateReadNext(Gate): NULL) )

Definition at line 69 of file mio.h.

Typedef Documentation

typedef struct Mio_Cell_t_ Mio_Cell_t

Definition at line 46 of file mio.h.

typedef struct Mio_GateStruct_t_ Mio_Gate_t

Definition at line 43 of file mio.h.

typedef struct Mio_LibraryStruct_t_ Mio_Library_t

Definition at line 42 of file mio.h.

typedef struct Mio_PinStruct_t_ Mio_Pin_t

Definition at line 44 of file mio.h.

Enumeration Type Documentation

enum Mio_PinPhase_t

INCLUDES ///.

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

FileName [mio.h]

PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]

Synopsis [File reading/writing for technology mapping.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - September 8, 2003.]

Revision [

Id:

mio.h,v 1.6 2004/08/09 22:16:31 satrajit Exp

]PARAMETERS ///STRUCTURE DEFINITIONS ///

Enumerator
MIO_PHASE_UNKNOWN
MIO_PHASE_INV
MIO_PHASE_NONINV

Definition at line 40 of file mio.h.

{ MIO_PHASE_UNKNOWN, MIO_PHASE_INV, MIO_PHASE_NONINV } Mio_PinPhase_t;

Function Documentation

Mio_Library_t* Abc_SclDeriveGenlib	(	void *	pScl,
		float	Slew,
		float	Gain,
		int	nGatesMin,
		int	fVerbose
	)

Definition at line 818 of file sclLibUtil.c.

{
    int nCellCount = 0;
    SC_Lib * p = (SC_Lib *)pScl;
    float Slew = (SlewInit == 0) ? Abc_SclComputeAverageSlew(p) : SlewInit;
    Vec_Str_t * vStr = Abc_SclProduceGenlibStr( p, Slew, Gain, nGatesMin, &nCellCount );
    Mio_Library_t * pLib = Mio_LibraryRead( p->pFileName, Vec_StrArray(vStr), NULL, 0 );  
    Vec_StrFree( vStr );
    if ( !pLib )
        printf( "Reading library has filed.\n" );
    else if ( fVerbose )
        printf( "Derived GENLIB library \"%s\" with %d gates using slew %.2f ps and gain %.2f.\n", p->pName, nCellCount, Slew, Gain );
    return pLib;
}

Mio_Library_t* Abc_SclDeriveGenlibSimple

(

void *

pScl

)

Definition at line 710 of file sclLibUtil.c.

{
    SC_Lib * p = (SC_Lib *)pScl;
    Vec_Str_t * vStr = Abc_SclProduceGenlibStrSimple( p );
    Mio_Library_t * pLib = Mio_LibraryRead( p->pFileName, Vec_StrArray(vStr), NULL, 0 );  
    Vec_StrFree( vStr );
    if ( pLib )
        printf( "Derived GENLIB library \"%s\" with %d gates.\n", p->pName, SC_LibCellNum(p) );
    else
        printf( "Reading library has filed.\n" );
    return pLib;
}

int Abc_SclHasDelayInfo

(

void *

pScl

)

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

Synopsis [Returns 1 if the library has delay info.]

Description []

SideEffects []

SeeAlso []

Definition at line 292 of file sclLibUtil.c.

{
    SC_Lib * p = (SC_Lib *)pScl;
    SC_Cell * pCell;
    SC_Timing * pTime;
    pCell = Abc_SclFindInvertor(p, 0);
    if ( pCell == NULL )
        return 0;
    pTime = Scl_CellPinTime( pCell, 0 );
    if ( pTime == NULL )
        return 0;
    return 1;
}

Mio_Gate_t** Mio_CollectRoots	(	Mio_Library_t *	pLib,
		int	nInputs,
		float	tDelay,
		int	fSkipInv,
		int *	pnGates,
		int	fVerbose
	)

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

Synopsis [Collects the set of root gates.]

Description [Only collects the gates with unique functionality, which have fewer inputs and shorter delay than the given limits.]

SideEffects []

SeeAlso []

Definition at line 302 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_Gate_t ** ppGates;
    int i, nGates, iGate;
    nGates = Mio_LibraryReadGateNum( pLib );
    ppGates = ABC_ALLOC( Mio_Gate_t *, nGates );
    iGate = 0;
    // for each functionality, select gate with the smallest area
    // if equal areas, select gate with lexicographically smaller name
    Mio_LibraryForEachGate( pLib, pGate )
    {
        if ( pGate->nInputs > nInputs )
            continue;
        if ( tDelay > 0.0 && pGate->dDelayMax > (double)tDelay )
            continue;
        if ( pGate->uTruth == 0 || pGate->uTruth == ~(word)0 )
            continue;
        if ( pGate->uTruth == ABC_CONST(0xAAAAAAAAAAAAAAAA) )
            continue;
        if ( pGate->uTruth == ~ABC_CONST(0xAAAAAAAAAAAAAAAA) && fSkipInv )
            continue;
        if ( pGate->pTwin ) // skip multi-output gates for now
            continue;
        // check if the gate with this functionality already exists
        for ( i = 0; i < iGate; i++ )
            if ( ppGates[i]->uTruth == pGate->uTruth )
            {
                if ( ppGates[i]->dArea > pGate->dArea || 
                    (ppGates[i]->dArea == pGate->dArea && strcmp(ppGates[i]->pName, pGate->pName) > 0) )
                    ppGates[i] = pGate;
                break;
            }
        if ( i < iGate )
            continue;
        assert( iGate < nGates );
        ppGates[ iGate++ ] = pGate;
        if ( fVerbose )
            printf( "Selected gate %3d:   %-20s  A = %7.2f  D = %7.2f  %3s = %-s\n", 
                iGate+1, pGate->pName, pGate->dArea, pGate->dDelayMax, pGate->pOutName, pGate->pForm );
    }
    // sort by delay
    if ( iGate > 0 ) 
    {
        qsort( (void *)ppGates, iGate, sizeof(Mio_Gate_t *), 
                (int (*)(const void *, const void *)) Mio_DelayCompare );
        assert( Mio_DelayCompare( ppGates, ppGates + iGate - 1 ) <= 0 );
    }
    if ( pnGates )
        *pnGates = iGate;
    return ppGates;
}

Mio_Cell_t* Mio_CollectRootsNew	(	Mio_Library_t *	pLib,
		int	nInputs,
		int *	pnGates,
		int	fVerbose
	)

Definition at line 404 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_Cell_t * ppCells;
    int i, nGates, iCell = 4;
    nGates = Mio_LibraryReadGateNum( pLib );
    ppCells = ABC_CALLOC( Mio_Cell_t, nGates + 4 );
    // for each functionality, select gate with the smallest area
    // if equal areas, select gate with lexicographically smaller name
    Mio_LibraryForEachGate( pLib, pGate )
    {
        if ( pGate->nInputs > nInputs || pGate->pTwin ) // skip large and multi-output
            continue;
        // check if the gate with this functionality already exists
        for ( i = 0; i < iCell; i++ )
            if ( ppCells[i].pName && ppCells[i].uTruth == pGate->uTruth )
            {
                if ( ppCells[i].Area > pGate->dArea || 
                    (ppCells[i].Area == pGate->dArea && strcmp(ppCells[i].pName, pGate->pName) > 0) )
                {
                    Mio_CollectCopy( ppCells + i, pGate );
                }
                break;
            }
        if ( i < iCell )
            continue;
        if ( pGate->uTruth == 0 || pGate->uTruth == ~(word)0 )
        {
            int Idx = (int)(pGate->uTruth == ~(word)0);
            assert( pGate->nInputs == 0 );
            Mio_CollectCopy( ppCells + Idx, pGate );
            continue;
        }
        if ( pGate->uTruth == ABC_CONST(0xAAAAAAAAAAAAAAAA) || pGate->uTruth == ~ABC_CONST(0xAAAAAAAAAAAAAAAA) )
        {
            int Idx = 2 + (int)(pGate->uTruth == ~ABC_CONST(0xAAAAAAAAAAAAAAAA));
            assert( pGate->nInputs == 1 );
            Mio_CollectCopy( ppCells + Idx, pGate );
            continue;
        }
        Mio_CollectCopy( ppCells + iCell++, pGate );
    }
    if ( ppCells[0].pName == NULL )
        { printf( "Error: Cannot find constant 0 gate in the library.\n" ); return NULL; }
    if ( ppCells[1].pName == NULL )
        { printf( "Error: Cannot find constant 1 gate in the library.\n" ); return NULL; }
    if ( ppCells[2].pName == NULL )
        { printf( "Error: Cannot find buffer gate in the library.\n" );     return NULL; }
    if ( ppCells[3].pName == NULL )
        { printf( "Error: Cannot find inverter gate in the library.\n" );   return NULL; }
    // sort by delay
    if ( iCell > 1 ) 
    {
        qsort( (void *)(ppCells + 4), iCell - 4, sizeof(Mio_Cell_t), 
                (int (*)(const void *, const void *)) Mio_DelayCompareNew );
        assert( Mio_DelayCompareNew( ppCells + 4, ppCells + iCell - 1 ) <= 0 );
    }
    // assign IDs
    for ( i = 0; i < iCell; i++ )
        ppCells[i].Id = ppCells[i].pName ? i : -1;

    // report
    if ( fVerbose )
    {
        // count gates
        int * pCounts = ABC_CALLOC( int, nGates + 4 );
        Mio_LibraryForEachGate( pLib, pGate )
        {
            if ( pGate->nInputs > nInputs || pGate->pTwin ) // skip large and multi-output
                continue;
            for ( i = 0; i < iCell; i++ )
                if ( ppCells[i].pName && ppCells[i].uTruth == pGate->uTruth )
                {
                    pCounts[i]++;
                    break;
                }
            assert( i < iCell );
        }
        for ( i = 0; i < iCell; i++ )
        {
            Mio_Cell_t * pCell = ppCells + i;
            printf( "%4d : ", i );
            if ( pCell->pName == NULL )
                printf( "None\n" );
            else
                printf( "%-20s   In = %d   N = %3d   A = %7.2f   D = %7.2f\n", 
                    pCell->pName, pCell->nFanins, pCounts[i], pCell->Area, pCell->Delays[0] );
        }
        ABC_FREE( pCounts );
    }
    if ( pnGates )
        *pnGates = iCell;
    return ppCells;
}

Mio_Cell_t* Mio_CollectRootsNewDefault	(	int	nInputs,
		int *	pnGates,
		int	fVerbose
	)

Definition at line 498 of file mioUtils.c.

{
    return Mio_CollectRootsNew( (Mio_Library_t *)Abc_FrameReadLibGen(), nInputs, pnGates, fVerbose );
}

void Mio_DeriveGateDelays	(	Mio_Gate_t *	pGate,
		float **	ptPinDelays,
		int	nPins,
		int	nInputs,
		float	tDelayZero,
		float *	ptDelaysRes,
		float *	ptPinDelayMax
	)

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

Synopsis [Derives the area and delay of the root of the gate.]

Description [Array of the resulting delays should be initialized to the (negative) SUPER_NO_VAR value.]

SideEffects []

SeeAlso []

Definition at line 725 of file mioUtils.c.

{
    Mio_Pin_t * pPin;
    float Delay, DelayMax;
    int i, k;
    assert( pGate->nInputs == nPins );
    // set all the delays to the unused delay
    for ( i = 0; i < nInputs; i++ )
        ptDelaysRes[i] = tDelayZero;
    // compute the delays for each input and the max delay at the same time
    DelayMax = 0;
    for ( i = 0; i < nInputs; i++ )
    {
        for ( k = 0, pPin = pGate->pPins; pPin; pPin = pPin->pNext, k++ )
        {
            if ( ptPinDelays[k][i] < 0 )
                continue;
            Delay = ptPinDelays[k][i] + (float)pPin->dDelayBlockMax;
            if ( ptDelaysRes[i] < Delay )
                ptDelaysRes[i] = Delay;
        }
        if ( k != nPins )
        {
            printf ("DEBUG: problem gate is %s\n", Mio_GateReadName( pGate ));
        }
        assert( k == nPins );
        if ( DelayMax < ptDelaysRes[i] )
            DelayMax = ptDelaysRes[i];
    }
    *ptPinDelayMax = DelayMax;
}

void Mio_DeriveTruthTable	(	Mio_Gate_t *	pGate,
		unsigned	uTruthsIn[][2],
		int	nSigns,
		int	nInputs,
		unsigned	uTruthRes[]
	)

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

Synopsis [Derives the truth table of the gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 608 of file mioUtils.c.

{
    word uRes, uFanins[6];
    int i;
    assert( pGate->nInputs == nSigns );
    for ( i = 0; i < nSigns; i++ )
        uFanins[i] = (((word)uTruthsIn[i][1]) << 32) | (word)uTruthsIn[i][0];
    uRes = Exp_Truth6( nSigns, pGate->vExpr, (word *)uFanins );
    uTruthRes[0] = uRes & 0xFFFFFFFF;
    uTruthRes[1] = uRes >> 32;
}

word Mio_DeriveTruthTable6

(

Mio_Gate_t *

pGate

)

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

Synopsis [Derives the truth table of the gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 514 of file mioUtils.c.

{
    static unsigned uTruths6[6][2] = {
        { 0xAAAAAAAA, 0xAAAAAAAA },
        { 0xCCCCCCCC, 0xCCCCCCCC },
        { 0xF0F0F0F0, 0xF0F0F0F0 },
        { 0xFF00FF00, 0xFF00FF00 },
        { 0xFFFF0000, 0xFFFF0000 },
        { 0x00000000, 0xFFFFFFFF }
    };
    union {
      unsigned u[2];
      word w;
    } uTruthRes;
    assert( pGate->nInputs <= 6 );
    Mio_DeriveTruthTable( pGate, uTruths6, pGate->nInputs, 6, uTruthRes.u );
    return uTruthRes.w;
}

Mio_Gate_t* Mio_GateCreatePseudo

(

int

nInputs

)

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

Synopsis [Creates a pseudo-gate.]

Description [The pseudo-gate is a N-input gate with all info set to 0.]

SideEffects []

SeeAlso []

Definition at line 771 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_Pin_t * pPin;
    int i;
    // allocate the gate structure
    pGate = ABC_ALLOC( Mio_Gate_t, 1 );
    memset( pGate, 0, sizeof(Mio_Gate_t) );
    pGate->nInputs = nInputs;
    // create pins
    for ( i = 0; i < nInputs; i++ )
    {
        pPin = ABC_ALLOC( Mio_Pin_t, 1 );
        memset( pPin, 0, sizeof(Mio_Pin_t) );
        pPin->pNext = pGate->pPins;
        pGate->pPins = pPin;
    }
    return pGate;
}

void Mio_GateDelete

(

Mio_Gate_t *

pGate

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 81 of file mioUtils.c.

{
    Mio_Pin_t * pPin, * pPin2;
    if ( pGate->nInputs > 6 )
        ABC_FREE( pGate->pTruth );
    Vec_IntFreeP( &pGate->vExpr );
    ABC_FREE( pGate->pOutName );
    ABC_FREE( pGate->pName );
    ABC_FREE( pGate->pForm );
//    if ( pGate->bFunc )
//        Cudd_RecursiveDeref( pGate->pLib->dd, pGate->bFunc );
    Mio_GateForEachPinSafe( pGate, pPin, pPin2 )
        Mio_PinDelete( pPin );   
    ABC_FREE( pGate );
}

double Mio_GateReadArea

(

Mio_Gate_t *

pGate

)

Definition at line 145 of file mioApi.c.

{ return pGate->dArea;     }

double Mio_GateReadDelayMax

(

Mio_Gate_t *

pGate

)

Definition at line 152 of file mioApi.c.

{ return pGate->dDelayMax; }

char* Mio_GateReadForm

(

Mio_Gate_t *

pGate

)

Definition at line 146 of file mioApi.c.

{ return pGate->pForm;     }

Mio_Library_t* Mio_GateReadLib

(

Mio_Gate_t *

pGate

)

Definition at line 148 of file mioApi.c.

{ return pGate->pLib;      }

char* Mio_GateReadName

(

Mio_Gate_t *

pGate

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 143 of file mioApi.c.

{ return pGate->pName;     }

Mio_Gate_t* Mio_GateReadNext

(

Mio_Gate_t *

pGate

)

Definition at line 149 of file mioApi.c.

{ return pGate->pNext;     }

char* Mio_GateReadOutName

(

Mio_Gate_t *

pGate

)

Definition at line 144 of file mioApi.c.

{ return pGate->pOutName;  }

float Mio_GateReadPinDelay	(	Mio_Gate_t *	pGate,
		int	iPin
	)

Definition at line 201 of file mioApi.c.

{
    Mio_Pin_t * pPin;
    int i = 0;
    Mio_GateForEachPin( pGate, pPin )
        if ( i++ == iPin )
            return 0.5 * pPin->dDelayBlockRise + 0.5 * pPin->dDelayBlockFall;
    return ABC_INFINITY;
}

char* Mio_GateReadPinName	(	Mio_Gate_t *	pGate,
		int	iPin
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 192 of file mioApi.c.

{
    Mio_Pin_t * pPin;
    int i = 0;
    Mio_GateForEachPin( pGate, pPin )
        if ( i++ == iPin )
            return Mio_PinReadName(pPin);
    return NULL;
}

int Mio_GateReadPinNum

(

Mio_Gate_t *

pGate

)

Definition at line 151 of file mioApi.c.

{ return pGate->nInputs;   }

Mio_Pin_t* Mio_GateReadPins

(

Mio_Gate_t *

pGate

)

Definition at line 147 of file mioApi.c.

{ return pGate->pPins;     }

char* Mio_GateReadSop

(

Mio_Gate_t *

pGate

)

Definition at line 153 of file mioApi.c.

{ return pGate->pSop;      }

word Mio_GateReadTruth

(

Mio_Gate_t *

pGate

)

Definition at line 154 of file mioApi.c.

{ return pGate->nInputs <= 6 ? pGate->uTruth : 0;   }

Mio_Gate_t* Mio_GateReadTwin

(

Mio_Gate_t *

pGate

)

Definition at line 150 of file mioApi.c.

{ return pGate->pTwin;     }

int Mio_GateReadValue

(

Mio_Gate_t *

pGate

)

Definition at line 156 of file mioApi.c.

{ return pGate->Value;     }

void Mio_GateSetValue	(	Mio_Gate_t *	pGate,
		int	Value
	)

Definition at line 157 of file mioApi.c.

{ pGate->Value = Value;    }

char* Mio_LibDeriveSop	(	int	nVars,
		Vec_Int_t *	vExpr,
		Vec_Str_t *	vStr
	)

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

Synopsis [Derives SOP representation.]

Description [The SOP is guaranteed to be SCC-free but not minimal.]

SideEffects []

SeeAlso []

Definition at line 257 of file mioSop.c.

{
    Vec_Int_t * vSop;
    Vec_Ptr_t * vSops0, * vSops1, * vTemp;
    int i, Index0, Index1, fCompl0, fCompl1;
    Vec_StrClear( vStr );
    if ( Exp_IsConst0(vExpr) )
    {
        Vec_StrPrintStr( vStr, " 0\n" );
        Vec_StrPush( vStr, '\0' );
        return Vec_StrArray( vStr );
    }
    if ( Exp_IsConst1(vExpr) )
    {
        Vec_StrPrintStr( vStr, " 1\n" );
        Vec_StrPush( vStr, '\0' );
        return Vec_StrArray( vStr );
    }
    if ( Exp_IsLit(vExpr) )
    {
        for ( i = 0; i < nVars; i++ )
            Vec_StrPush( vStr, '-' );
        Vec_StrPrintStr( vStr, " 1\n" );
        Vec_StrPush( vStr, '\0' );
        assert( (Vec_IntEntry(vExpr,0) >> 1) < nVars );
        Vec_StrWriteEntry( vStr, Vec_IntEntry(vExpr,0) >> 1, (char)('1' - (Vec_IntEntry(vExpr,0) & 1)) );
        return Vec_StrArray( vStr );
    }
    vSops0 = Vec_PtrAlloc( nVars + Exp_NodeNum(vExpr) );
    vSops1 = Vec_PtrAlloc( nVars + Exp_NodeNum(vExpr) );
    for ( i = 0; i < nVars; i++ )
    {
        Vec_PtrPush( vSops0, Mio_SopVar0(i) );
        Vec_PtrPush( vSops1, Mio_SopVar1(i) );
    }
    for ( i = 0; i < Exp_NodeNum(vExpr); i++ )
    {
        Index0  = Vec_IntEntry( vExpr, 2*i+0 ) >> 1;
        Index1  = Vec_IntEntry( vExpr, 2*i+1 ) >> 1;
        fCompl0 = Vec_IntEntry( vExpr, 2*i+0 ) & 1;
        fCompl1 = Vec_IntEntry( vExpr, 2*i+1 ) & 1;
        // positive polarity
        vSop = Mio_SopCoverAnd( fCompl0 ? (Vec_Int_t *)Vec_PtrEntry(vSops0, Index0) : (Vec_Int_t *)Vec_PtrEntry(vSops1, Index0),
                                fCompl1 ? (Vec_Int_t *)Vec_PtrEntry(vSops0, Index1) : (Vec_Int_t *)Vec_PtrEntry(vSops1, Index1) );
        Vec_PtrPush( vSops1, vSop );
        // negative polarity
        vSop = Mio_SopCoverOr( fCompl0 ? (Vec_Int_t *)Vec_PtrEntry(vSops1, Index0) : (Vec_Int_t *)Vec_PtrEntry(vSops0, Index0),
                               fCompl1 ? (Vec_Int_t *)Vec_PtrEntry(vSops1, Index1) : (Vec_Int_t *)Vec_PtrEntry(vSops0, Index1) );
        Vec_PtrPush( vSops0, vSop );
    }
    // complement
    if ( Vec_IntEntryLast(vExpr) & 1 )
    {
        vTemp  = vSops0;
        vSops0 = vSops1;
        vSops1 = vTemp;
    }
    // select the best polarity
    if ( Vec_IntSize( (Vec_Int_t *)Vec_PtrEntryLast(vSops0) ) < Vec_IntSize( (Vec_Int_t *)Vec_PtrEntryLast(vSops1) ) )
        vSop = (Vec_Int_t *)Vec_PtrEntryLast(vSops0);
    else
        vSop = (Vec_Int_t *)Vec_PtrEntryLast(vSops1);
    // convert positive polarity into SOP
    Mio_SopDeriveFromArray( vSop, nVars, vStr, (vSop == Vec_PtrEntryLast(vSops1)) );
    Vec_VecFree( (Vec_Vec_t *)vSops0 );
    Vec_VecFree( (Vec_Vec_t *)vSops1 );
    return Vec_StrArray( vStr );
}

void Mio_LibraryDelete

(

Mio_Library_t *

pLib

)

DECLARATIONS ///.

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

FileName [mioUtils.c]

PackageName [MVSIS 1.3: Multi-valued logic synthesis system.]

Synopsis [File reading/writing for technology mapping.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - September 8, 2003.]

Revision [

Id:

mioUtils.c,v 1.6 2004/09/03 18:02:20 satrajit Exp

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 48 of file mioUtils.c.

{
    Mio_Gate_t * pGate, * pGate2;
    if ( pLib == NULL )
        return;
    // free the bindings of nodes to gates from this library for all networks
    Abc_FrameUnmapAllNetworks( Abc_FrameGetGlobalFrame() );
    // free the library
    ABC_FREE( pLib->pName );
    Mio_LibraryForEachGateSafe( pLib, pGate, pGate2 )
        Mio_GateDelete( pGate );
    Mem_FlexStop( pLib->pMmFlex, 0 );
    Vec_StrFree( pLib->vCube );
    if ( pLib->tName2Gate )
        st__free_table( pLib->tName2Gate );
//    if ( pLib->dd )
//        Cudd_Quit( pLib->dd );
    ABC_FREE( pLib->ppGates0 );
    ABC_FREE( pLib->ppGatesName );
    ABC_FREE( pLib );
}

void Mio_LibraryMultiArea	(	Mio_Library_t *	pLib,
		double	Multi
	)

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

Synopsis [Multiply areas/delays by values proportional to fanin count.]

Description []

SideEffects []

SeeAlso []

Definition at line 829 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_LibraryForEachGate( pLib, pGate )
    {
        if ( pGate->nInputs < 2 )
            continue;
//        printf( "Before %8.3f  ", pGate->dArea );
        pGate->dArea *= pow( pGate->nInputs, Multi );
//        printf( "After %8.3f  Inputs = %d. Factor = %8.3f\n", pGate->dArea, pGate->nInputs, pow( pGate->nInputs, Multi ) );
    }
}

void Mio_LibraryMultiDelay	(	Mio_Library_t *	pLib,
		double	Multi
	)

Definition at line 841 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_Pin_t * pPin;
    Mio_LibraryForEachGate( pLib, pGate )
    {
        if ( pGate->nInputs < 2 )
            continue;
//        printf( "Before %8.3f  ", pGate->dDelayMax );
        pGate->dDelayMax *= pow( pGate->nInputs, Multi );
//        printf( "After %8.3f  Inputs = %d. Factor = %8.3f\n", pGate->dDelayMax, pGate->nInputs, pow( pGate->nInputs, Multi ) );
        Mio_GateForEachPin( pGate, pPin )
        {
            pPin->dDelayBlockRise *= pow( pGate->nInputs, Multi );
            pPin->dDelayBlockFall *= pow( pGate->nInputs, Multi );
            pPin->dDelayBlockMax  *= pow( pGate->nInputs, Multi );
        }
    }
}

int Mio_LibraryParseFormulas

(

Mio_Library_t *

pLib

)

FUNCTION DEFINITIONS ///.

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

Synopsis [Deriving the functionality of the gates.]

Description []

SideEffects []

SeeAlso []

Definition at line 58 of file mioForm.c.

{
    Mio_Gate_t * pGate;

    // count the gates
    pLib->nGates = 0;
    Mio_LibraryForEachGate( pLib, pGate )
        pLib->nGates++;        

    // start a temporary BDD manager
    pLib->dd = Cudd_Init( 20, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
    // introduce ZDD variables
    Cudd_zddVarsFromBddVars( pLib->dd, 2 );

    // for each gate, derive its function
    Mio_LibraryForEachGate( pLib, pGate )
        if ( Mio_GateParseFormula( pGate ) )
            return 1;
    return 0;
}

Mio_Library_t* Mio_LibraryRead	(	char *	FileName,
		char *	pBuffer,
		char *	ExcludeFile,
		int	fVerbose
	)

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

Synopsis [Read the genlib type of library.]

Description []

SideEffects []

SeeAlso []

Definition at line 54 of file mioRead.c.

{
    Mio_Library_t * pLib;
    int num;

    st__table * tExcludeGate = 0;

    if ( ExcludeFile )
    {
        tExcludeGate = st__init_table(strcmp, st__strhash);
        if ( (num = Mio_LibraryReadExclude( ExcludeFile, tExcludeGate )) == -1 )
        {
            st__free_table( tExcludeGate );
            tExcludeGate = 0;
            return 0;
        }
        fprintf ( stdout, "Read %d gates from exclude file\n", num );
    }

    if ( pBuffer == NULL )
        pLib = Mio_LibraryReadOne( FileName, 0, tExcludeGate, fVerbose );       // try normal format first ..
    else
    {
        pLib = Mio_LibraryReadBuffer( pBuffer, 0, tExcludeGate, fVerbose );       // try normal format first ..
        if ( pLib )
            pLib->pName = Abc_UtilStrsav( Extra_FileNameGenericAppend(FileName, ".genlib") );
    }
    if ( pLib == NULL )
    {
        if ( pBuffer == NULL )
            pLib = Mio_LibraryReadOne( FileName, 1, tExcludeGate, fVerbose );       // try normal format first ..
        else
        {
            pLib = Mio_LibraryReadBuffer( pBuffer, 1, tExcludeGate, fVerbose );       // try normal format first ..
            if ( pLib )
                pLib->pName = Abc_UtilStrsav( Extra_FileNameGenericAppend(FileName, ".genlib") );
        }
        if ( pLib != NULL )
            printf ( "Warning: Read extended genlib format but ignoring extensions\n" );
    }
    if ( tExcludeGate )
        st__free_table( tExcludeGate );

    return pLib;
}

Mio_Gate_t* Mio_LibraryReadAnd2

(

Mio_Library_t *

pLib

)

Definition at line 52 of file mioApi.c.

{ return pLib->pGateAnd2;  }

float Mio_LibraryReadAreaBuf

(

Mio_Library_t *

pLib

)

Definition at line 61 of file mioApi.c.

{ return (float)(pLib->pGateBuf?   pLib->pGateBuf->dArea   : 0.0); }

float Mio_LibraryReadAreaInv

(

Mio_Library_t *

pLib

)

Definition at line 60 of file mioApi.c.

{ return (float)(pLib->pGateInv?   pLib->pGateInv->dArea   : 0.0); }

float Mio_LibraryReadAreaNand2

(

Mio_Library_t *

pLib

)

Definition at line 62 of file mioApi.c.

{ return (float)(pLib->pGateNand2? pLib->pGateNand2->dArea : 0.0); }

Mio_Gate_t* Mio_LibraryReadBuf

(

Mio_Library_t *

pLib

)

Definition at line 47 of file mioApi.c.

{ return pLib->pGateBuf;   }

Mio_Gate_t* Mio_LibraryReadConst0

(

Mio_Library_t *

pLib

)

Definition at line 49 of file mioApi.c.

{ return pLib->pGate0;     }

Mio_Gate_t* Mio_LibraryReadConst1

(

Mio_Library_t *

pLib

)

Definition at line 50 of file mioApi.c.

{ return pLib->pGate1;     }

float Mio_LibraryReadDelayAnd2Max

(

Mio_Library_t *

pLib

)

Definition at line 59 of file mioApi.c.

{ return (float)(pLib->pGateAnd2?  pLib->pGateAnd2->pPins->dDelayBlockMax   : 0.0); }

float Mio_LibraryReadDelayInvFall

(

Mio_Library_t *

pLib

)

Definition at line 54 of file mioApi.c.

{ return (float)(pLib->pGateInv?   pLib->pGateInv->pPins->dDelayBlockFall   : 0.0); }

float Mio_LibraryReadDelayInvMax

(

Mio_Library_t *

pLib

)

Definition at line 55 of file mioApi.c.

{ return (float)(pLib->pGateInv?   pLib->pGateInv->pPins->dDelayBlockMax    : 0.0); }

float Mio_LibraryReadDelayInvRise

(

Mio_Library_t *

pLib

)

Definition at line 53 of file mioApi.c.

{ return (float)(pLib->pGateInv?   pLib->pGateInv->pPins->dDelayBlockRise   : 0.0); }

float Mio_LibraryReadDelayNand2Fall

(

Mio_Library_t *

pLib

)

Definition at line 57 of file mioApi.c.

{ return (float)(pLib->pGateNand2? pLib->pGateNand2->pPins->dDelayBlockFall : 0.0); }

float Mio_LibraryReadDelayNand2Max

(

Mio_Library_t *

pLib

)

Definition at line 58 of file mioApi.c.

{ return (float)(pLib->pGateNand2? pLib->pGateNand2->pPins->dDelayBlockMax  : 0.0); }

float Mio_LibraryReadDelayNand2Rise

(

Mio_Library_t *

pLib

)

Definition at line 56 of file mioApi.c.

{ return (float)(pLib->pGateNand2? pLib->pGateNand2->pPins->dDelayBlockRise : 0.0); }

int Mio_LibraryReadExclude	(	char *	ExcludeFile,
		st__table *	tExcludeGate
	)

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

Synopsis [populate hash table of gates to be exlcuded from genlib]

Description []

SideEffects []

SeeAlso []

Definition at line 654 of file mioRead.c.

{
    int nDel = 0;
    FILE *pEx;
    char buffer[128];

    assert ( tExcludeGate );

    if ( ExcludeFile )
    {
        pEx = fopen( ExcludeFile, "r" );

        if ( pEx == NULL )
        {
            fprintf ( stdout, "Error: Could not open exclude file %s. Stop.\n", ExcludeFile );
            return -1;
        }

        while (1 == fscanf( pEx, "%127s", buffer ))
        {
            //printf ("Read: '%s'\n", buffer );
            st__insert( tExcludeGate, Abc_UtilStrsav( buffer ), (char *)0 );
            nDel++;
        }

        fclose( pEx );
    }

    return nDel;
}

Mio_Gate_t** Mio_LibraryReadGateArray

(

Mio_Library_t *

pLib

)

Definition at line 46 of file mioApi.c.

{ return pLib->ppGatesName;}

Mio_Gate_t* Mio_LibraryReadGateByName	(	Mio_Library_t *	pLib,
		char *	pName,
		char *	pOutName
	)

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

Synopsis [Read Mvc of the gate by name.]

Description []

SideEffects []

SeeAlso []

Definition at line 99 of file mioApi.c.

{ 
    Mio_Gate_t * pGate;
    if ( ! st__lookup( pLib->tName2Gate, pName, (char **)&pGate ) )
        return NULL;
    if ( pOutName == NULL )
        return pGate;
    if ( !strcmp(pGate->pOutName, pOutName) )
        return pGate;
    if ( pGate->pTwin && !strcmp(pGate->pTwin->pOutName, pOutName) )
        return pGate->pTwin;
    return NULL;
}

int Mio_LibraryReadGateNameMax

(

Mio_Library_t *

pLib

)

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

Synopsis [Returns the longest gate name.]

Description []

SideEffects []

SeeAlso []

Definition at line 75 of file mioApi.c.

{
    Mio_Gate_t * pGate;
    int LenMax = 0, LenCur;
    Mio_LibraryForEachGate( pLib, pGate )
    {
        LenCur = strlen( Mio_GateReadName(pGate) );
        if ( LenMax < LenCur )
            LenMax = LenCur;
    }
    return LenMax;
}

int Mio_LibraryReadGateNum

(

Mio_Library_t *

pLib

)

Definition at line 44 of file mioApi.c.

{ return pLib->nGates;     }

Mio_Gate_t* Mio_LibraryReadGates

(

Mio_Library_t *

pLib

)

Definition at line 45 of file mioApi.c.

{ return pLib->pGates;     }

Mio_Gate_t* Mio_LibraryReadInv

(

Mio_Library_t *

pLib

)

Definition at line 48 of file mioApi.c.

{ return pLib->pGateInv;   }

char* Mio_LibraryReadName

(

Mio_Library_t *

pLib

)

DECLARATIONS ///.

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

FileName [mioApi.c]

PackageName [MVSIS 1.3: Multi-valued logic synthesis system.]

Synopsis [File reading/writing for technology mapping.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - September 8, 2003.]

Revision [

Id:

mioApi.c,v 1.4 2004/06/28 14:20:25 alanmi Exp

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 43 of file mioApi.c.

{ return pLib->pName;      }

Mio_Gate_t* Mio_LibraryReadNand2

(

Mio_Library_t *

pLib

)

Definition at line 51 of file mioApi.c.

{ return pLib->pGateNand2; }

char* Mio_LibraryReadSopByName	(	Mio_Library_t *	pLib,
		char *	pName
	)

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

Synopsis [Read Mvc of the gate by name.]

Description []

SideEffects []

SeeAlso []

Definition at line 124 of file mioApi.c.

{ 
    Mio_Gate_t * pGate;
    if ( st__lookup( pLib->tName2Gate, pName, (char **)&pGate ) )
        return pGate->pSop;
    return NULL;
}

void Mio_LibraryShiftDelay	(	Mio_Library_t *	pLib,
		double	Shift
	)

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

Synopsis [Adds constant value to all delay values.]

Description [The pseudo-gate is a N-input gate with all info set to 0.]

SideEffects []

SeeAlso []

Definition at line 802 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_Pin_t * pPin;
    Mio_LibraryForEachGate( pLib, pGate )
    {
        pGate->dDelayMax += Shift;
        Mio_GateForEachPin( pGate, pPin )
        {
            pPin->dDelayBlockRise += Shift;
            pPin->dDelayBlockFall += Shift;
            pPin->dDelayBlockMax  += Shift;
        }
    }
}

void Mio_LibraryTransferDelays	(	Mio_Library_t *	pLibD,
		Mio_Library_t *	pLibS
	)

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

Synopsis [Transfers delays from the second to the first.]

Description []

SideEffects []

SeeAlso []

Definition at line 872 of file mioUtils.c.

{
    Mio_Gate_t * pGateD, * pGateS;
    Mio_Pin_t * pPinD, * pPinS;
    Mio_LibraryForEachGate( pLibS, pGateS )
    {
        Mio_LibraryForEachGate( pLibD, pGateD )
        {
            if ( pGateD->uTruth != pGateS->uTruth )
                continue;
            pPinS = Mio_GateReadPins( pGateS );
            Mio_GateForEachPin( pGateD, pPinD )
            {
                if (pPinS)
                {
                    pPinD->dDelayBlockRise = pPinS->dDelayBlockRise;
                    pPinD->dDelayBlockFall = pPinS->dDelayBlockFall;
                    pPinD->dDelayBlockMax  = pPinS->dDelayBlockMax;
                    pPinS = Mio_PinReadNext(pPinS);
                }
                else
                {
                    pPinD->dDelayBlockRise = 0;
                    pPinD->dDelayBlockFall = 0;
                    pPinD->dDelayBlockMax  = 0;
                }
            }
        }
    }
}

int Mio_ParseCheckFormula	(	Mio_Gate_t *	pGate,
		char *	pForm
	)

Definition at line 444 of file mioParse.c.

{
    Mio_Pin_t * pPin;
    char * pStr;
    int i, iPin, fVisit[32] = {0};
    if ( Mio_GateReadPins(pGate) == NULL || !strcmp(Mio_PinReadName(Mio_GateReadPins(pGate)), "*") )
        return 1;
/*
    // find the equality sign
    pForm = strstr( pForm, "=" );
    if ( pForm == NULL )
    {
        printf( "Skipping gate \"%s\" because formula \"%s\" has not equality sign (=).\n", pGate->pName, pForm );
        return 0;
    }
*/
//printf( "Checking gate %s\n", pGate->pName );

    for ( pStr = pForm; *pStr; pStr++ )
    {
        if ( *pStr == ' ' ||
             *pStr == MIO_EQN_SYM_OPEN ||   
             *pStr == MIO_EQN_SYM_CLOSE ||  
             *pStr == MIO_EQN_SYM_CONST0 || 
             *pStr == MIO_EQN_SYM_CONST1 || 
             *pStr == MIO_EQN_SYM_NEG ||    
             *pStr == MIO_EQN_SYM_NEGAFT || 
             *pStr == MIO_EQN_SYM_AND ||    
             *pStr == MIO_EQN_SYM_AND2 ||   
             *pStr == MIO_EQN_SYM_XOR ||    
             *pStr == MIO_EQN_SYM_OR ||     
             *pStr == MIO_EQN_SYM_OR2 
           )
           continue;
        // return the number of the pin which has this name
        iPin = Mio_ParseCheckName( pGate, &pStr );
        if ( iPin == -1 )
        {
            printf( "Skipping gate \"%s\" because substring \"%s\" does not match with a pin name.\n", pGate->pName, pStr );
            return 0;
        }
        assert( iPin < 32 );
        fVisit[iPin] = 1;
    }
    // check that all pins are used
    for ( pPin = Mio_GateReadPins(pGate), i = 0; pPin; pPin = Mio_PinReadNext(pPin), i++ )
        if ( fVisit[i] == 0 )
        {
//            printf( "Skipping gate \"%s\" because pin \"%s\" does not appear in the formula \"%s\".\n", pGate->pName, Mio_PinReadName(pPin), pForm );
            return 0;
        }
    return 1;
}

Vec_Int_t* Mio_ParseFormula	(	char *	pFormInit,
		char **	ppVarNames,
		int	nVars
	)

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

Synopsis [Derives the AIG corresponding to the equation.]

Description [Takes the stream to output messages, the formula, the vector of variable names and the AIG manager.]

SideEffects []

SeeAlso []

Definition at line 105 of file mioParse.c.

{
    char * pFormula;
    int Man = nVars, * pMan = &Man;
    Vec_Ptr_t * pStackFn;
    Vec_Int_t * pStackOp;
    Vec_Int_t * gFunc;
    char * pTemp, * pName;
    int nParans, fFound, Flag;
    int Oper, Oper1, Oper2;
    int i, v;

    // make sure that the number of opening and closing parantheses is the same
    nParans = 0;
    for ( pTemp = pFormInit; *pTemp; pTemp++ )
        if ( *pTemp == '(' )
            nParans++;
        else if ( *pTemp == ')' )
            nParans--;
    if ( nParans != 0 )
    {
        fprintf( stdout, "Mio_ParseFormula(): Different number of opening and closing parantheses ().\n" );
        return NULL;
    }

    // copy the formula
    pFormula = ABC_ALLOC( char, strlen(pFormInit) + 3 );
    sprintf( pFormula, "(%s)", pFormInit );

    // start the stacks
    pStackFn = Vec_PtrAlloc( 100 );
    pStackOp = Vec_IntAlloc( 100 );

    Flag = MIO_EQN_FLAG_START;
    for ( pTemp = pFormula; *pTemp; pTemp++ )
    {
        switch ( *pTemp )
        {
        // skip all spaces, tabs, and end-of-lines
        case ' ':
        case '\t':
        case '\r':
        case '\n':
            continue;
        case MIO_EQN_SYM_CONST0:
            Vec_PtrPush( pStackFn, Exp_Const0() );  // Cudd_Ref( b0 );
            if ( Flag == MIO_EQN_FLAG_VAR )
            {
                fprintf( stdout, "Mio_ParseFormula(): No operation symbol before constant 0.\n" );
                Flag = MIO_EQN_FLAG_ERROR; 
                break;
            }
            Flag = MIO_EQN_FLAG_VAR; 
            break;
        case MIO_EQN_SYM_CONST1:
            Vec_PtrPush( pStackFn, Exp_Const1() );  //  Cudd_Ref( b1 );
            if ( Flag == MIO_EQN_FLAG_VAR )
            {
                fprintf( stdout, "Mio_ParseFormula(): No operation symbol before constant 1.\n" );
                Flag = MIO_EQN_FLAG_ERROR; 
                break;
            }
            Flag = MIO_EQN_FLAG_VAR; 
            break;
        case MIO_EQN_SYM_NEG:
            if ( Flag == MIO_EQN_FLAG_VAR )
            {// if NEGBEF follows a variable, AND is assumed
                Vec_IntPush( pStackOp, MIO_EQN_OPER_AND );
                Flag = MIO_EQN_FLAG_OPER;
            }
            Vec_IntPush( pStackOp, MIO_EQN_OPER_NEG );
            break;
        case MIO_EQN_SYM_NEGAFT:
            if ( Flag != MIO_EQN_FLAG_VAR )
            {// if there is no variable before NEGAFT, it is an error
                fprintf( stdout, "Mio_ParseFormula(): No variable is specified before the negation suffix.\n" );
                Flag = MIO_EQN_FLAG_ERROR; 
                break;
            }
            else // if ( Flag == PARSE_FLAG_VAR )
                Vec_PtrPush( pStackFn, Exp_Not( (Vec_Int_t *)Vec_PtrPop(pStackFn) ) );
            break;
        case MIO_EQN_SYM_AND:
        case MIO_EQN_SYM_AND2:
        case MIO_EQN_SYM_OR:
        case MIO_EQN_SYM_OR2:
        case MIO_EQN_SYM_XOR:
            if ( Flag != MIO_EQN_FLAG_VAR )
            {
                fprintf( stdout, "Mio_ParseFormula(): There is no variable before AND, EXOR, or OR.\n" );
                Flag = MIO_EQN_FLAG_ERROR; 
                break;
            }
            if ( *pTemp == MIO_EQN_SYM_AND || *pTemp == MIO_EQN_SYM_AND2 )
                Vec_IntPush( pStackOp, MIO_EQN_OPER_AND );
            else if ( *pTemp == MIO_EQN_SYM_OR || *pTemp == MIO_EQN_SYM_OR2 )
                Vec_IntPush( pStackOp, MIO_EQN_OPER_OR );
            else //if ( *pTemp == MIO_EQN_SYM_XOR )
                Vec_IntPush( pStackOp, MIO_EQN_OPER_XOR );
            Flag = MIO_EQN_FLAG_OPER; 
            break;
        case MIO_EQN_SYM_OPEN:
            if ( Flag == MIO_EQN_FLAG_VAR )
            {
                Vec_IntPush( pStackOp, MIO_EQN_OPER_AND );
//              fprintf( stdout, "Mio_ParseFormula(): An opening paranthesis follows a var without operation sign.\n" ); 
//              Flag = MIO_EQN_FLAG_ERROR; 
//              break; 
            }
            Vec_IntPush( pStackOp, MIO_EQN_OPER_MARK );
            // after an opening bracket, it feels like starting over again
            Flag = MIO_EQN_FLAG_START; 
            break;
        case MIO_EQN_SYM_CLOSE:
            if ( Vec_IntSize( pStackOp ) != 0 )
            {
                while ( 1 )
                {
                    if ( Vec_IntSize( pStackOp ) == 0 )
                    {
                        fprintf( stdout, "Mio_ParseFormula(): There is no opening paranthesis\n" );
                        Flag = MIO_EQN_FLAG_ERROR; 
                        break;
                    }
                    Oper = Vec_IntPop( pStackOp );
                    if ( Oper == MIO_EQN_OPER_MARK )
                        break;

                    // perform the given operation
                    if ( Mio_ParseFormulaOper( pMan, nVars, pStackFn, Oper ) == NULL )
                    {
                        fprintf( stdout, "Mio_ParseFormula(): Unknown operation\n" );
                        ABC_FREE( pFormula );
                        Vec_PtrFreeP( &pStackFn );
                        Vec_IntFreeP( &pStackOp );
                        return NULL;
                    }
                }
            }
            else
            {
                fprintf( stdout, "Mio_ParseFormula(): There is no opening paranthesis\n" );
                Flag = MIO_EQN_FLAG_ERROR; 
                break;
            }
            if ( Flag != MIO_EQN_FLAG_ERROR )
                Flag = MIO_EQN_FLAG_VAR; 
            break;


        default:
            // scan the next name
            for ( i = 0; pTemp[i] && 
                         pTemp[i] != ' ' && pTemp[i] != '\t' && pTemp[i] != '\r' && pTemp[i] != '\n' &&
                         pTemp[i] != MIO_EQN_SYM_AND && pTemp[i] != MIO_EQN_SYM_AND2 && pTemp[i] != MIO_EQN_SYM_OR && pTemp[i] != MIO_EQN_SYM_OR2 && 
                         pTemp[i] != MIO_EQN_SYM_XOR && pTemp[i] != MIO_EQN_SYM_NEGAFT && pTemp[i] != MIO_EQN_SYM_CLOSE; 
                  i++ )
              {
                    if ( pTemp[i] == MIO_EQN_SYM_NEG || pTemp[i] == MIO_EQN_SYM_OPEN )
                    {
                        fprintf( stdout, "Mio_ParseFormula(): The negation sign or an opening paranthesis inside the variable name.\n" );
                        Flag = MIO_EQN_FLAG_ERROR; 
                        break;
                    }
              }
            // variable name is found
            fFound = 0;
//            Vec_PtrForEachEntry( char *, vVarNames, pName, v )
            for ( v = 0; v < nVars; v++ )
            {
                pName = ppVarNames[v];
                if ( strncmp(pTemp, pName, i) == 0 && strlen(pName) == (unsigned)i )
                {
                    pTemp += i-1;
                    fFound = 1;
                    break;
                }
            }
            if ( !fFound )
            { 
                fprintf( stdout, "Mio_ParseFormula(): The parser cannot find var \"%s\" in the input var list.\n", pTemp ); 
                Flag = MIO_EQN_FLAG_ERROR; 
                break; 
            }
/*
            if ( Flag == MIO_EQN_FLAG_VAR )
            {
                fprintf( stdout, "Mio_ParseFormula(): The variable name \"%s\" follows another var without operation sign.\n", pTemp ); 
                Flag = MIO_EQN_FLAG_ERROR; 
                break; 
            }
*/
            if ( Flag == MIO_EQN_FLAG_VAR )
                Vec_IntPush( pStackOp, MIO_EQN_OPER_AND );

            Vec_PtrPush( pStackFn, Exp_Var(v) ); // Cudd_Ref( pbVars[v] );
            Flag = MIO_EQN_FLAG_VAR; 
            break;
        }

        if ( Flag == MIO_EQN_FLAG_ERROR )
            break;      // error exit
        else if ( Flag == MIO_EQN_FLAG_START )
            continue;  //  go on parsing
        else if ( Flag == MIO_EQN_FLAG_VAR )
            while ( 1 )
            {  // check if there are negations in the OpStack     
                if ( Vec_IntSize( pStackOp ) == 0 )
                    break;
                Oper = Vec_IntPop( pStackOp );
                if ( Oper != MIO_EQN_OPER_NEG )
                {
                    Vec_IntPush( pStackOp, Oper );
                    break;
                }
                else
                {
                    Vec_PtrPush( pStackFn, Exp_Not((Vec_Int_t *)Vec_PtrPop(pStackFn)) );
                }
            }
        else // if ( Flag == MIO_EQN_FLAG_OPER )
            while ( 1 )
            {  // execute all the operations in the OpStack
               // with precedence higher or equal than the last one
                Oper1 = Vec_IntPop( pStackOp ); // the last operation
                if ( Vec_IntSize( pStackOp ) == 0 ) 
                {  // if it is the only operation, push it back
                    Vec_IntPush( pStackOp, Oper1 );
                    break;
                }
                Oper2 = Vec_IntPop( pStackOp ); // the operation before the last one
                if ( Oper2 >= Oper1 )  
                {  // if Oper2 precedence is higher or equal, execute it
                    if ( Mio_ParseFormulaOper( pMan, nVars, pStackFn, Oper2 ) == NULL )
                    {
                        fprintf( stdout, "Mio_ParseFormula(): Unknown operation\n" );
                        ABC_FREE( pFormula );
                        Vec_PtrFreeP( &pStackFn );
                        Vec_IntFreeP( &pStackOp );
                        return NULL;
                    }
                    Vec_IntPush( pStackOp,  Oper1 );     // push the last operation back
                }
                else
                {  // if Oper2 precedence is lower, push them back and done
                    Vec_IntPush( pStackOp, Oper2 );
                    Vec_IntPush( pStackOp, Oper1 );
                    break;
                }
            }
    }

    if ( Flag != MIO_EQN_FLAG_ERROR )
    {
        if ( Vec_PtrSize(pStackFn) != 0 )
        {   
            gFunc = (Vec_Int_t *)Vec_PtrPop(pStackFn);
            if ( Vec_PtrSize(pStackFn) == 0 )
                if ( Vec_IntSize( pStackOp ) == 0 )
                {
//                    Cudd_Deref( gFunc );
                    ABC_FREE( pFormula );
                    Vec_PtrFreeP( &pStackFn );
                    Vec_IntFreeP( &pStackOp );
                    return Exp_Reverse(gFunc);
                }
                else
                    fprintf( stdout, "Mio_ParseFormula(): Something is left in the operation stack\n" );
            else
                fprintf( stdout, "Mio_ParseFormula(): Something is left in the function stack\n" );
        }
        else
            fprintf( stdout, "Mio_ParseFormula(): The input string is empty\n" );
    }
    ABC_FREE( pFormula );
    Vec_PtrFreeP( &pStackFn );
    Vec_IntFreeP( &pStackOp );
    return NULL;
}

Vec_Wrd_t* Mio_ParseFormulaTruth	(	char *	pFormInit,
		char **	ppVarNames,
		int	nVars
	)

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

Synopsis [Derives the TT corresponding to the equation.]

Description []

SideEffects []

SeeAlso []

Definition at line 396 of file mioParse.c.

{
    Vec_Int_t * vExpr;
    Vec_Wrd_t * vTruth;
    // derive expression
    vExpr = Mio_ParseFormula( pFormInit, ppVarNames, nVars );
    if ( vExpr == NULL )
        return NULL;
    // convert it into a truth table
    vTruth = Vec_WrdStart( Abc_Truth6WordNum(nVars) );
    Exp_Truth( nVars, vExpr, Vec_WrdArray(vTruth) );
    Vec_IntFree( vExpr );
    return vTruth;
}

void Mio_PinDelete

(

Mio_Pin_t *

pPin

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 108 of file mioUtils.c.

{
    ABC_FREE( pPin->pName );
    ABC_FREE( pPin );
}

Mio_Pin_t* Mio_PinDup

(

Mio_Pin_t *

pPin

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 125 of file mioUtils.c.

{
    Mio_Pin_t * pPinNew;

    pPinNew = ABC_ALLOC( Mio_Pin_t, 1 );
    *pPinNew = *pPin;
    pPinNew->pName = (pPinNew->pName ? Abc_UtilStrsav(pPinNew->pName) : NULL);
    pPinNew->pNext = NULL;

    return pPinNew;
}

double Mio_PinReadDelayBlockFall

(

Mio_Pin_t *

pPin

)

Definition at line 176 of file mioApi.c.

{ return pPin->dDelayBlockFall; }

double Mio_PinReadDelayBlockMax

(

Mio_Pin_t *

pPin

)

Definition at line 178 of file mioApi.c.

{ return pPin->dDelayBlockMax;          }

double Mio_PinReadDelayBlockRise

(

Mio_Pin_t *

pPin

)

Definition at line 174 of file mioApi.c.

{ return pPin->dDelayBlockRise; }

double Mio_PinReadDelayFanoutFall

(

Mio_Pin_t *

pPin

)

Definition at line 177 of file mioApi.c.

{ return pPin->dDelayFanoutFall;}

double Mio_PinReadDelayFanoutRise

(

Mio_Pin_t *

pPin

)

Definition at line 175 of file mioApi.c.

{ return pPin->dDelayFanoutRise;}

double Mio_PinReadInputLoad

(

Mio_Pin_t *

pPin

)

Definition at line 172 of file mioApi.c.

{ return pPin->dLoadInput;      }

double Mio_PinReadMaxLoad

(

Mio_Pin_t *

pPin

)

Definition at line 173 of file mioApi.c.

{ return pPin->dLoadMax;        }

char* Mio_PinReadName

(

Mio_Pin_t *

pPin

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 170 of file mioApi.c.

{ return pPin->pName;           }

Mio_Pin_t* Mio_PinReadNext

(

Mio_Pin_t *

pPin

)

Definition at line 179 of file mioApi.c.

{ return pPin->pNext;           }

Mio_PinPhase_t Mio_PinReadPhase

(

Mio_Pin_t *

pPin

)

Definition at line 171 of file mioApi.c.

{ return pPin->Phase;           }

char* Mio_ReadFile	(	char *	FileName,
		int	fAddEnd
	)

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

Synopsis [Read contents of the file.]

Description []

SideEffects []

SeeAlso []

Definition at line 111 of file mioRead.c.

{
    char * pBuffer;
    FILE * pFile;
    int nFileSize;
    int RetValue;

    // open the BLIF file for binary reading
    pFile = Io_FileOpen( FileName, "open_path", "rb", 1 );
//    pFile = fopen( FileName, "rb" );
    // if we got this far, file should be okay otherwise would
    // have been detected by caller
    assert ( pFile != NULL );
    // get the file size, in bytes
    fseek( pFile, 0, SEEK_END );  
    nFileSize = ftell( pFile );  
    // move the file current reading position to the beginning
    rewind( pFile ); 
    // load the contents of the file into memory
    pBuffer   = ABC_ALLOC( char, nFileSize + 10 );
    RetValue = fread( pBuffer, nFileSize, 1, pFile );
    // terminate the string with '\0'
    pBuffer[ nFileSize ] = '\0';
    if ( fAddEnd )
        strcat( pBuffer, "\n.end\n" );
    // close file
    fclose( pFile );
    return pBuffer;
}

void Mio_UpdateGenlib

(

Mio_Library_t *

pLib

)

FUNCTION DEFINITIONS ///.

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 124 of file mio.c.

{
    // free the current superlib because it depends on the old Mio library
    if ( Abc_FrameReadLibSuper() )
    {
        Map_SuperLibFree( (Map_SuperLib_t *)Abc_FrameReadLibSuper() );
        Abc_FrameSetLibSuper( NULL );
    }

    // replace the current library
    Mio_LibraryDelete( (Mio_Library_t *)Abc_FrameReadLibGen() );
    Abc_FrameSetLibGen( pLib );

    // replace the current library
    Amap_LibFree( (Amap_Lib_t *)Abc_FrameReadLibGen2() );
    Abc_FrameSetLibGen2( NULL );
}

int Mio_UpdateGenlib2	(	Vec_Str_t *	vStr,
		Vec_Str_t *	vStr2,
		char *	pFileName,
		int	fVerbose
	)

Definition at line 141 of file mio.c.

{
    Mio_Library_t * pLib;
    // set the new network
    pLib = Mio_LibraryRead( pFileName, Vec_StrArray(vStr), NULL, fVerbose );  
    if ( pLib == NULL )
        return 0;

    // free the current superlib because it depends on the old Mio library
    if ( Abc_FrameReadLibSuper() )
    {
        Map_SuperLibFree( (Map_SuperLib_t *)Abc_FrameReadLibSuper() );
        Abc_FrameSetLibSuper( NULL );
    }

    // replace the current library
    Mio_LibraryDelete( (Mio_Library_t *)Abc_FrameReadLibGen() );
    Abc_FrameSetLibGen( pLib );

    // set the new network
    pLib = (Mio_Library_t *)Amap_LibReadAndPrepare( pFileName, Vec_StrArray(vStr2), 0, 0 );  
    if ( pLib == NULL )
        return 0;

    // replace the current library
    Amap_LibFree( (Amap_Lib_t *)Abc_FrameReadLibGen2() );
    Abc_FrameSetLibGen2( pLib );
    return 1;
}

void Mio_WriteLibrary	(	FILE *	pFile,
		Mio_Library_t *	pLib,
		int	fPrintSops
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 251 of file mioUtils.c.

{
    Mio_Gate_t * pGate;
    Mio_Pin_t * pPin;
    int i, GateLen = 0, NameLen = 0, FormLen = 0;
    int fAllPins = Mio_CheckGates( pLib );
    Mio_LibraryForEachGate( pLib, pGate )
    {
        GateLen = Abc_MaxInt( GateLen, strlen(pGate->pName) );
        NameLen = Abc_MaxInt( NameLen, strlen(pGate->pOutName) );
        FormLen = Abc_MaxInt( FormLen, strlen(pGate->pForm) );
        Mio_GateForEachPin( pGate, pPin )
            NameLen = Abc_MaxInt( NameLen, strlen(pPin->pName) );
    }
    fprintf( pFile, "# The genlib library \"%s\" written by ABC on %s\n\n", pLib->pName, Extra_TimeStamp() );
    for ( i = 0; i < pLib->nGates; i++ )
        Mio_WriteGate( pFile, pLib->ppGates0[i], GateLen, NameLen, FormLen, fPrintSops, fAllPins );
}