mioFunc.c File Reference

#include "mioInt.h"
#include "exp.h"

Include dependency graph for mioFunc.c:

Go to the source code of this file.

Macros
#define	MIO_SYMB_AND   '*'
	DECLARATIONS ///.
#define	MIO_SYMB_AND2   '&'
#define	MIO_SYMB_OR   '+'
#define	MIO_SYMB_OR2   '|'
#define	MIO_SYMB_XOR   '^'
#define	MIO_SYMB_NOT   '!'
#define	MIO_SYMB_AFTNOT   '\''
#define	MIO_SYMB_OPEN   '('
#define	MIO_SYMB_CLOSE   ')'

Functions
char *	Mio_SopRegister (Mem_Flex_t *pMan, char *pName)
	FUNCTION DEFINITIONS ///.
int	Mio_GateCollectNames (char *pFormula, char *pPinNames[])
int	Mio_GateParseFormula (Mio_Gate_t *pGate)
int	Mio_LibraryParseFormulas (Mio_Library_t *pLib)
	FUNCTION DEFINITIONS ///.

Macro Definition Documentation

MIO_SYMB_AFTNOT

#define MIO_SYMB_AFTNOT   '\''

Definition at line 37 of file mioFunc.c.

MIO_SYMB_AND

#define MIO_SYMB_AND   '*'

DECLARATIONS ///.

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

FileName [mioFunc.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

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

]

Definition at line 31 of file mioFunc.c.

MIO_SYMB_AND2

#define MIO_SYMB_AND2   '&'

Definition at line 32 of file mioFunc.c.

MIO_SYMB_CLOSE

#define MIO_SYMB_CLOSE   ')'

Definition at line 39 of file mioFunc.c.

MIO_SYMB_NOT

#define MIO_SYMB_NOT   '!'

Definition at line 36 of file mioFunc.c.

MIO_SYMB_OPEN

#define MIO_SYMB_OPEN   '('

Definition at line 38 of file mioFunc.c.

MIO_SYMB_OR

#define MIO_SYMB_OR   '+'

Definition at line 33 of file mioFunc.c.

MIO_SYMB_OR2

#define MIO_SYMB_OR2   '|'

Definition at line 34 of file mioFunc.c.

MIO_SYMB_XOR

#define MIO_SYMB_XOR   '^'

Definition at line 35 of file mioFunc.c.

Function Documentation

Mio_GateCollectNames()

int Mio_GateCollectNames	(	char *	pFormula,
		char *	pPinNames[] )

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

Synopsis [Collect the pin names in the formula.]

Description []

SideEffects []

SeeAlso []

Definition at line 76 of file mioFunc.c.

{
    char * Buffer;
    char * pTemp;
    int nPins, i;
 
    // save the formula as it was
    //strcpy( Buffer, pFormula );
    Buffer = Abc_UtilStrsav( pFormula );
 
    // remove the non-name symbols
    for ( pTemp = Buffer; *pTemp; pTemp++ )
        if ( *pTemp == MIO_SYMB_AND  || *pTemp == MIO_SYMB_AND2   || 
             *pTemp == MIO_SYMB_OR   || *pTemp == MIO_SYMB_OR2    || 
             *pTemp == MIO_SYMB_XOR  || 
             *pTemp == MIO_SYMB_NOT  || *pTemp == MIO_SYMB_AFTNOT ||
             *pTemp == MIO_SYMB_OPEN || *pTemp == MIO_SYMB_CLOSE )
             *pTemp = ' ';
 
    // save the names
    nPins = 0;
    pTemp = strtok( Buffer, " " );
    while ( pTemp )
    {
        for ( i = 0; i < nPins; i++ )
            if ( strcmp( pTemp, pPinNames[i] ) == 0 )
                break;
        if ( i == nPins )
        { // cannot find this name; save it
            pPinNames[nPins++] = Abc_UtilStrsav(pTemp);
        }
        // get the next name
        pTemp = strtok( NULL, " " );
    }
    ABC_FREE( Buffer );
    return nPins;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_GateParseFormula()

int Mio_GateParseFormula

(

Mio_Gate_t *

pGate

)

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

Synopsis [Deriving the functionality of the gates.]

Description []

SideEffects []

SeeAlso []

Definition at line 125 of file mioFunc.c.

{
    char * pPinNames[100];
    char * pPinNamesCopy[100];
    Mio_Pin_t * pPin, ** ppPin;
    int nPins, iPin, i;
 
    // set the maximum delay of the gate; count pins
    pGate->dDelayMax = 0.0;
    nPins = 0;
    Mio_GateForEachPin( pGate, pPin )
    {
        // set the maximum delay of the gate
        if ( pGate->dDelayMax < pPin->dDelayBlockMax )
            pGate->dDelayMax = pPin->dDelayBlockMax;
        // count the pin
        nPins++;
    }
 
    // check for the gate with const function
    if ( nPins == 0 )
    {
        if ( strcmp( pGate->pForm, MIO_STRING_CONST0 ) == 0 )
        {
//            pGate->bFunc = b0;
            pGate->vExpr = Exp_Const0();
            pGate->pSop = Mio_SopRegister( (Mem_Flex_t *)pGate->pLib->pMmFlex, " 0\n" );
            pGate->uTruth = 0;
            pGate->pLib->pGate0 = pGate;
        }
        else if ( strcmp( pGate->pForm, MIO_STRING_CONST1 ) == 0 )
        {
//            pGate->bFunc = b1;
            pGate->vExpr = Exp_Const1();
            pGate->pSop = Mio_SopRegister( (Mem_Flex_t *)pGate->pLib->pMmFlex, " 1\n" );
            pGate->uTruth = ~(word)0;
            pGate->pLib->pGate1 = pGate;
        }
        else
        {
            printf( "Cannot parse formula \"%s\" of gate \"%s\".\n", pGate->pForm, pGate->pName );
            return 1;
        }
//        Cudd_Ref( pGate->bFunc );
        return 0;
    }
 
    // collect the names as they appear in the formula
    nPins = Mio_GateCollectNames( pGate->pForm, pPinNames );
    if ( nPins == 0 )
    {
        printf( "Cannot read formula \"%s\" of gate \"%s\".\n", pGate->pForm, pGate->pName );
        return 1;
    }
 
    // set the number of inputs
    pGate->nInputs = nPins;
 
    // consider the case when all the pins have identical pin info
    if ( strcmp( pGate->pPins->pName, "*" ) == 0 )
    {
        // get the topmost (generic) pin
        pPin = pGate->pPins;
        ABC_FREE( pPin->pName );
 
        // create individual pins from the generic pin
        ppPin = &pPin->pNext;
        for ( i = 1; i < nPins; i++ )
        {
            // get the new pin
            *ppPin = Mio_PinDup( pPin );
            // set its name
            (*ppPin)->pName = pPinNames[i];
            // prepare the next place in the list
            ppPin = &((*ppPin)->pNext);
        }
        *ppPin = NULL;
 
        // set the name of the topmost pin
        pPin->pName = pPinNames[0];
    }
    else
    {
        // reorder the variable names to appear the save way as the pins
        iPin = 0;
        Mio_GateForEachPin( pGate, pPin )
        {
            // find the pin with the name pPin->pName
            for ( i = 0; i < nPins; i++ )
            {
                if ( pPinNames[i] && strcmp( pPinNames[i], pPin->pName ) == 0 )
                {
                    // free pPinNames[i] because it is already available as pPin->pName
                    // setting pPinNames[i] to NULL is useful to make sure that
                    // this name is not assigned to two pins in the list
                    ABC_FREE( pPinNames[i] );
                    pPinNamesCopy[iPin++] = pPin->pName;
                    break;
                }
                if ( i == nPins )
                {
                    printf( "Cannot find pin name \"%s\" in the formula \"%s\" of gate \"%s\".\n", 
                        pPin->pName, pGate->pForm, pGate->pName );
                    return 1;
                }
            }
        }
 
        // check for the remaining names
        for ( i = 0; i < nPins; i++ )
            if ( pPinNames[i] )
            {
                printf( "Name \"%s\" appears in the formula \"%s\" of gate \"%s\" but there is no such pin.\n", 
                    pPinNames[i], pGate->pForm, pGate->pName );
                return 1;
            }
 
        // copy the names back
        memcpy( pPinNames, pPinNamesCopy, nPins * sizeof(char *) );
    }
/*
    // expand the manager if necessary
    if ( dd->size < nPins )
    {
        Cudd_Quit( dd );
        dd = Cudd_Init( nPins + 10, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
        Cudd_zddVarsFromBddVars( dd, 2 );
    }
    // derive formula as the BDD
    pGate->bFunc = Parse_FormulaParser( stdout, pGate->pForm, nPins, 0, pPinNames, dd, dd->vars );
    if ( pGate->bFunc == NULL )
        return 1;
    Cudd_Ref( pGate->bFunc );
    // derive cover
    pGate->pSop = Abc_ConvertBddToSop( pGate->pLib->pMmFlex, dd, pGate->bFunc, pGate->bFunc, nPins, 0, pGate->pLib->vCube, -1 );
*/
 
    // derive expression 
    pGate->vExpr = Mio_ParseFormula( pGate->pForm, (char **)pPinNames, nPins );
//    Mio_ParseFormulaTruthTest( pGate->pForm, (char **)pPinNames, nPins );
    // derive cover
    pGate->pSop = Mio_LibDeriveSop( nPins, pGate->vExpr, pGate->pLib->vCube );
    pGate->pSop = Mio_SopRegister( (Mem_Flex_t *)pGate->pLib->pMmFlex, pGate->pSop );
    // derive truth table
    if ( nPins <= 6 )
        pGate->uTruth = Exp_Truth6( nPins, pGate->vExpr, NULL );
    else if ( nPins <= 8 )
    {
        pGate->pTruth = ABC_CALLOC( word, 4 );
        Exp_Truth8( nPins, pGate->vExpr, NULL, pGate->pTruth );
    }
 
/*
    // verify
    if ( pGate->nInputs <= 6 )
    {
        extern word Abc_SopToTruth( char * pSop, int nInputs );
        word t2 = Abc_SopToTruth( pGate->pSop, nPins );
        if ( pGate->uTruth != t2 )
        {
            printf( "%s\n", pGate->pForm );
            Exp_Print( nPins, pGate->vExpr );
            printf( "Verification failed!\n" );
        }
    }
*/
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_LibraryParseFormulas()

int Mio_LibraryParseFormulas

(

Mio_Library_t *

pLib

)

FUNCTION DEFINITIONS ///.

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

Synopsis [Deriving the functionality of the gates.]

Description []

SideEffects []

SeeAlso []

Definition at line 305 of file mioFunc.c.

{
    Mio_Gate_t * pGate;
 
    // count the gates
    pLib->nGates = 0;
    Mio_LibraryForEachGate( pLib, pGate )
        pLib->nGates++;        
 
    // for each gate, derive its function
    Mio_LibraryForEachGate( pLib, pGate )
        if ( Mio_GateParseFormula( pGate ) )
            return 1;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Mio_SopRegister()

char * Mio_SopRegister	(	Mem_Flex_t *	pMan,
		char *	pName )

FUNCTION DEFINITIONS ///.

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

Synopsis [Registers the cube string with the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 56 of file mioFunc.c.

{
    char * pRegName;
    if ( pName == NULL ) return NULL;
    pRegName = Mem_FlexEntryFetch( pMan, strlen(pName) + 1 );
    strcpy( pRegName, pName );
    return pRegName;
}

Here is the call graph for this function:

Here is the caller graph for this function: