#include <ctype.h>
#include "mioInt.h"
#include "base/io/ioAbc.h"

Functions
static ABC_NAMESPACE_IMPL_START Mio_Library_t *	Mio_LibraryReadOne (char FileName, int fExtendedFormat, st__table tExcludeGate, int fVerbose)
	DECLARATIONS ///. More...

static Mio_Library_t *	Mio_LibraryReadBuffer (char pBuffer, int fExtendedFormat, st__table tExcludeGate, int fVerbose)

static int	Mio_LibraryReadInternal (Mio_Library_t pLib, char pBuffer, int fExtendedFormat, st__table *tExcludeGate, int fVerbose)

static Mio_Gate_t *	Mio_LibraryReadGate (char **ppToken, int fExtendedFormat)

static Mio_Pin_t *	Mio_LibraryReadPin (char **ppToken, int fExtendedFormat)

static char *	chomp (char *s)

static void	Mio_LibraryDetectSpecialGates (Mio_Library_t *pLib)

static void	Io_ReadFileRemoveComments (char pBuffer, int pnDots, int *pnLines)

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

char *	Mio_ReadFile (char *FileName, int fAddEnd)

int	Mio_LibraryCompareGatesByArea (Mio_Gate_t pp1, Mio_Gate_t pp2)

int	Mio_LibraryCompareGatesByName (Mio_Gate_t pp1, Mio_Gate_t pp2)

void	Mio_LibrarySortGates (Mio_Library_t *pLib)

static Mio_Gate_t *	Mio_GateCompare (Mio_Gate_t pThis, Mio_Gate_t pNew, word uTruth)

int	Mio_LibraryReadExclude (char ExcludeFile, st__table tExcludeGate)

Function Documentation

char * chomp ( char * s )

static

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

Synopsis [Duplicates string and returns it with leading and trailing spaces removed.]

Description []

SideEffects []

SeeAlso []

Definition at line 483 of file mioRead.c.

 {
     char *a, *b, *c;
     // remove leading spaces
     for ( b = s; *b; b++ )
         if ( !isspace(*b) )
             break;
     // strsav the string
     a = strcpy( ABC_ALLOC(char, strlen(b)+1), b );
     // remove trailing spaces
     for ( c = a+strlen(a); c > a; c-- )
         if ( *c == 0 || isspace(*c) )
             *c = 0;
         else
             break;
     return a;
 }   

void Io_ReadFileRemoveComments	(	char *	pBuffer,
		int *	pnDots,
		int *	pnLines
	)

static

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

Synopsis [Eliminates comments from the input file.]

Description [As a byproduct, this procedure also counts the number lines and dot-statements in the input file. This also joins non-comment lines that are joined with a backspace '\']

SideEffects []

SeeAlso []

Definition at line 698 of file mioRead.c.

 {
     char * pCur;
     int nDots, nLines;
     // scan through the buffer and eliminate comments
     // (in the BLIF file, comments are lines starting with "#")
     nDots = nLines = 0;
     for ( pCur = pBuffer; *pCur; pCur++ )
     {
         // if this is the beginning of comment
         // clean it with spaces until the new line statement
         if ( *pCur == '#' )
             while ( *pCur != '\n' )
                 *pCur++ = ' ';
     
         // count the number of new lines and dots
         if ( *pCur == '\n' ) {
         if (*(pCur-1)=='\r') {
         // DOS(R) file support
         if (*(pCur-2)!='\\') nLines++;
         else {
             // rewind to backslash and overwrite with a space
             *(pCur-2) = ' ';
             *(pCur-1) = ' ';
             *pCur = ' ';
         }
         } else {
         // UNIX(TM) file support
         if (*(pCur-1)!='\\') nLines++;
         else {
             // rewind to backslash and overwrite with a space
             *(pCur-1) = ' ';
             *pCur = ' ';
         }
         }
     }
         else if ( *pCur == '.' )
             nDots++;
     }
     if ( pnDots )
         *pnDots = nDots; 
     if ( pnLines )
         *pnLines = nLines; 
 }

static Mio_Gate_t* Mio_GateCompare	(	Mio_Gate_t *	pThis,
		Mio_Gate_t *	pNew,
		word	uTruth
	)

inlinestatic

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 591 of file mioRead.c.

 {
     if ( pNew->uTruth != uTruth )
         return pThis;
     if ( pThis == NULL )
         return pNew;
     if ( pThis->dArea > pNew->dArea || (pThis->dArea == pNew->dArea && strcmp(pThis->pName, pNew->pName) > 0) )
         return pNew;
     return pThis;
 }

int Mio_LibraryCompareGatesByArea	(	Mio_Gate_t **	pp1,
		Mio_Gate_t **	pp2
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 512 of file mioRead.c.

 {
     double Diff = (*pp1)->dArea - (*pp2)->dArea;
     if ( Diff < 0.0 )
         return -1;
     if ( Diff > 0.0 ) 
         return 1;
     return 0; 
 }

int Mio_LibraryCompareGatesByName	(	Mio_Gate_t **	pp1,
		Mio_Gate_t **	pp2
	)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 533 of file mioRead.c.

 {
     int Diff = strcmp( (*pp1)->pName, (*pp2)->pName );
     if ( Diff < 0.0 )
         return -1;
     if ( Diff > 0.0 ) 
         return 1;
     return 0; 
 }

void Mio_LibraryDetectSpecialGates ( Mio_Library_t * pLib )

static

Definition at line 601 of file mioRead.c.

 {
     Mio_Gate_t * pGate;
     word uFuncBuf, uFuncInv, uFuncNand2, uFuncAnd2;
 
     Mio_LibrarySortGates( pLib );
 
     uFuncBuf   = ABC_CONST(0xAAAAAAAAAAAAAAAA);
     uFuncAnd2  = ABC_CONST(0xAAAAAAAAAAAAAAAA) & ABC_CONST(0xCCCCCCCCCCCCCCCC);
     uFuncInv   = ~uFuncBuf;
     uFuncNand2 = ~uFuncAnd2;
 
     // get smallest-area buffer
     Mio_LibraryForEachGate( pLib, pGate )
         pLib->pGateBuf = Mio_GateCompare( pLib->pGateBuf, pGate, uFuncBuf );
     if ( pLib->pGateBuf == NULL )
     {
         printf( "Warnings: genlib library reader cannot detect the buffer gate.\n" );
         printf( "Some parts of the supergate-based technology mapper may not work correctly.\n" );
     }
  
     // get smallest-area inverter
     Mio_LibraryForEachGate( pLib, pGate )
         pLib->pGateInv = Mio_GateCompare( pLib->pGateInv, pGate, uFuncInv );
     if ( pLib->pGateInv == NULL )
     {
         printf( "Warnings: genlib library reader cannot detect the invertor gate.\n" );
         printf( "Some parts of the supergate-based technology mapper may not work correctly.\n" );
     }
 
     // get smallest-area NAND2/AND2 gates
     Mio_LibraryForEachGate( pLib, pGate )
         pLib->pGateNand2 = Mio_GateCompare( pLib->pGateNand2, pGate, uFuncNand2 );
     Mio_LibraryForEachGate( pLib, pGate )
         pLib->pGateAnd2 = Mio_GateCompare( pLib->pGateAnd2, pGate, uFuncAnd2 );
     if ( pLib->pGateAnd2 == NULL && pLib->pGateNand2 == NULL )
     {
         printf( "Warnings: genlib library reader cannot detect the AND2 or NAND2 gate.\n" );
         printf( "Some parts of the supergate-based technology mapper may not work correctly.\n" );
     }
 }

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_Library_t * Mio_LibraryReadBuffer	(	char *	pBuffer,
		int	fExtendedFormat,
		st__table *	tExcludeGate,
		int	fVerbose
	)

static

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

Synopsis [Read the genlib type of library.]

Description []

SideEffects []

SeeAlso []

Definition at line 152 of file mioRead.c.

 {
     Mio_Library_t * pLib;
 
     // allocate the genlib structure
     pLib = ABC_CALLOC( Mio_Library_t, 1 );
     pLib->tName2Gate = st__init_table(strcmp, st__strhash);
     pLib->pMmFlex = Mem_FlexStart();
     pLib->vCube = Vec_StrAlloc( 100 );
 
     Io_ReadFileRemoveComments( pBuffer, NULL, NULL );
 
     // parse the contents of the file
     if ( Mio_LibraryReadInternal( pLib, pBuffer, fExtendedFormat, tExcludeGate, fVerbose ) )
     {
         Mio_LibraryDelete( pLib );
         return NULL;
     }
 
     // derive the functinality of gates
     if ( Mio_LibraryParseFormulas( pLib ) )
     {
         printf( "Mio_LibraryRead: Had problems parsing formulas.\n" );
         Mio_LibraryDelete( pLib );
         return NULL;
     }
 
     // detect INV and NAND2
     Mio_LibraryDetectSpecialGates( pLib );
 //Mio_WriteLibrary( stdout, pLib );
     return pLib;
 }

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_LibraryReadGate	(	char **	ppToken,
		int	fExtendedFormat
	)

static

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

Synopsis [Read the genlib type of gate.]

Description []

SideEffects []

SeeAlso []

Definition at line 332 of file mioRead.c.

 {
     Mio_Gate_t * pGate;
     Mio_Pin_t * pPin, ** ppPin;
     char * pToken = *ppToken;
 
     // allocate the gate structure
     pGate = ABC_CALLOC( Mio_Gate_t, 1 );
 
     // read the name
     pToken = strtok( NULL, " \t\r\n" );
     pGate->pName = Abc_UtilStrsav( pToken );
 
     // read the area
     pToken = strtok( NULL, " \t\r\n" );
     pGate->dArea = atof( pToken );
 
     // read the formula
 
     // first the output name
     pToken = strtok( NULL, "=" );
     pGate->pOutName = chomp( pToken );
 
     // then rest of the expression 
     pToken = strtok( NULL, ";" );
     pGate->pForm = chomp( pToken );
 
     // read the pin info
     // start the linked list of pins
     pGate->pPins = NULL;
     ppPin = &pGate->pPins;
 
     // read gates one by one
     pToken = strtok( NULL, " \t\r\n" );
     while ( pToken && strcmp( pToken, MIO_STRING_PIN ) == 0 )
     {
         // derive the next gate
         pPin = Mio_LibraryReadPin( &pToken, fExtendedFormat );
         if ( pPin == NULL )
         {
             Mio_GateDelete( pGate );
             *ppToken = pToken;
             return NULL;
         }
         // add this pin to the list
         *ppPin = pPin;
         ppPin  = &pPin->pNext;
         // get the next token
         pToken = strtok( NULL, " \t\r\n" );
     }
 
     *ppToken = pToken;
     return pGate;
 }

int Mio_LibraryReadInternal	(	Mio_Library_t *	pLib,
		char *	pBuffer,
		int	fExtendedFormat,
		st__table *	tExcludeGate,
		int	fVerbose
	)

static

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

Synopsis [Read the genlib type of library.]

Description []

SideEffects []

SeeAlso []

Definition at line 225 of file mioRead.c.

 {
     Mio_Gate_t * pGate, ** ppGate;
     char * pToken;
     int nGates = 0;
     int nDel = 0;
 
     // start the linked list of gates
     pLib->pGates = NULL;
     ppGate = &pLib->pGates;
 
     // read gates one by one
     pToken = strtok( pBuffer, " \t\r\n" );
     while ( pToken && (strcmp( pToken, MIO_STRING_GATE ) == 0 || strcmp( pToken, MIO_STRING_LATCH ) == 0) )
     {
         // skip latches
         if ( strcmp( pToken, MIO_STRING_LATCH ) == 0 )
         {
             while ( pToken && strcmp( pToken, MIO_STRING_GATE ) != 0 && strcmp( pToken, ".end" ) != 0 )
             {
                 if ( strcmp( pToken, MIO_STRING_LATCH ) == 0 )
                 {
                     pToken = strtok( NULL, " \t\r\n" );
                     printf( "Skipping latch \"%s\"...\n", pToken );
                     continue;
                 }
                 pToken = strtok( NULL, " \t\r\n" );
             }
             if ( !(pToken && strcmp( pToken, MIO_STRING_GATE ) == 0) )
                 break;
         }
 
         // derive the next gate
         pGate = Mio_LibraryReadGate( &pToken, fExtendedFormat );
         if ( pGate == NULL )
             return 1;
 
         // skip the gate if its formula has problems
         if ( !Mio_ParseCheckFormula(pGate, pGate->pForm) )
         {
             Mio_GateDelete( pGate );
             continue;
         }
        
         // set the library
         pGate->pLib = pLib;
 
         // printf ("Processing: '%s'\n", pGate->pName);
 
         if ( tExcludeGate && st__is_member( tExcludeGate, pGate->pName ) )
         {
             //printf ("Excluding: '%s'\n", pGate->pName);
             Mio_GateDelete( pGate );
             nDel++;
         } 
         else
         {
             // add this gate to the list
             *ppGate = pGate;
             ppGate  = &pGate->pNext;
             nGates++;
 
             // remember this gate by name
             if ( ! st__is_member( pLib->tName2Gate, pGate->pName ) )
                 st__insert( pLib->tName2Gate, pGate->pName, (char *)pGate );
             else
             {
                 Mio_Gate_t * pBase = Mio_LibraryReadGateByName( pLib, pGate->pName, NULL );
                 if ( pBase->pTwin != NULL )
                 {
                     printf( "Gates with more than 2 outputs are not supported.\n" );
                     continue;
                 }
                 pBase->pTwin = pGate;
                 pGate->pTwin = pBase;
 //                printf( "Gate \"%s\" appears two times. Creating a 2-output gate.\n", pGate->pName );
             }
         }
     }
 
     if ( nGates == 0 )
     {
         printf( "The library contains no gates.\n" );
         return 1;
     }
 
     // check what is the last word read
     if ( pToken && strcmp( pToken, ".end" ) != 0 )
         return 1;
 
     if ( nDel != 0 ) 
         printf( "Actually excluded %d cells\n", nDel );
 
     return 0;
 }

Mio_Library_t * Mio_LibraryReadOne	(	char *	FileName,
		int	fExtendedFormat,
		st__table *	tExcludeGate,
		int	fVerbose
	)

static

DECLARATIONS ///.

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

FileName [mioRead.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:: mioRead.c,v 1.9 2004/10/19 06:40:16 satrajit Exp

]FUNCTION DEFINITIONS ///

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

Synopsis [Read the genlib type of library.]

Description []

SideEffects []

SeeAlso []

Definition at line 196 of file mioRead.c.

 {
     Mio_Library_t * pLib;
     char * pBuffer;
     // read the file and clean comments
     // pBuffer = Io_ReadFileFileContents( FileName, NULL );
     // we don't use above function but actually do the same thing explicitly
     // to handle open_path expansion correctly
     pBuffer = Mio_ReadFile( FileName, 1 );
     if ( pBuffer == NULL )
         return NULL;
     pLib = Mio_LibraryReadBuffer( pBuffer, fExtendedFormat, tExcludeGate, fVerbose );
     ABC_FREE( pBuffer );
     if ( pLib )
         pLib->pName = Abc_UtilStrsav( FileName );
     return pLib;
 }

Mio_Pin_t * Mio_LibraryReadPin	(	char **	ppToken,
		int	fExtendedFormat
	)

static

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

Synopsis [Read the genlib type of pin.]

Description []

SideEffects []

SeeAlso []

Definition at line 400 of file mioRead.c.

 {
     Mio_Pin_t * pPin;
     char * pToken = *ppToken;
 
     // allocate the gate structure
     pPin = ABC_CALLOC( Mio_Pin_t, 1 );
 
     // read the name
     pToken = strtok( NULL, " \t\r\n" );
     pPin->pName = Abc_UtilStrsav( pToken );
 
     // read the pin phase
     pToken = strtok( NULL, " \t\r\n" );
     if ( strcmp( pToken, MIO_STRING_UNKNOWN ) == 0 )
         pPin->Phase = MIO_PHASE_UNKNOWN;
     else if ( strcmp( pToken, MIO_STRING_INV ) == 0 )
         pPin->Phase = MIO_PHASE_INV;
     else if ( strcmp( pToken, MIO_STRING_NONINV ) == 0 )
         pPin->Phase = MIO_PHASE_NONINV;
     else 
     {
         printf( "Cannot read pin phase specification\n" );
         Mio_PinDelete( pPin );
         *ppToken = pToken;
         return NULL;
     }
 
     pToken = strtok( NULL, " \t\r\n" );
     pPin->dLoadInput = atof( pToken );
 
     pToken = strtok( NULL, " \t\r\n" );
     pPin->dLoadMax = atof( pToken );
 
     pToken = strtok( NULL, " \t\r\n" );
     pPin->dDelayBlockRise = atof( pToken );
 
     pToken = strtok( NULL, " \t\r\n" );
     pPin->dDelayFanoutRise = atof( pToken );
 
     pToken = strtok( NULL, " \t\r\n" );
     pPin->dDelayBlockFall = atof( pToken );
 
     pToken = strtok( NULL, " \t\r\n" );
     pPin->dDelayFanoutFall = atof( pToken );
 
     if ( fExtendedFormat )
     {
         /* In extended format, the field after dDelayFanoutRise
          * is to be ignored
          **/
 
         pPin->dDelayBlockFall  = pPin->dDelayFanoutFall;
 
         pToken = strtok( NULL, " \t" );
         pPin->dDelayFanoutFall = atof( pToken );
 
         /* last field is ignored */
         pToken = strtok( NULL, " \t\r\n" );
     }
 
     if ( pPin->dDelayBlockRise > pPin->dDelayBlockFall )
         pPin->dDelayBlockMax = pPin->dDelayBlockRise;
     else
         pPin->dDelayBlockMax = pPin->dDelayBlockFall;
 
     *ppToken = pToken;
     return pPin;
 }

void Mio_LibrarySortGates ( Mio_Library_t * pLib )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 554 of file mioRead.c.

 {
     Mio_Gate_t ** ppGates, * pGate;
     int i = 0;
     ppGates = ABC_ALLOC( Mio_Gate_t *, pLib->nGates );
     Mio_LibraryForEachGate( pLib, pGate )
         ppGates[i++] = pGate;
     assert( i == pLib->nGates );
     // sort gates by area
     pLib->ppGates0 = ABC_ALLOC( Mio_Gate_t *, pLib->nGates );
     for ( i = 0; i < pLib->nGates; i++ )
         pLib->ppGates0[i] = ppGates[i];
     qsort( (void *)ppGates, pLib->nGates, sizeof(void *), 
             (int (*)(const void *, const void *)) Mio_LibraryCompareGatesByArea );
     for ( i = 0; i < pLib->nGates; i++ )
         ppGates[i]->pNext = (i < pLib->nGates-1)? ppGates[i+1] : NULL;
     pLib->pGates = ppGates[0];
     ABC_FREE( ppGates );
     // sort gates by name
     pLib->ppGatesName = ABC_ALLOC( Mio_Gate_t *, pLib->nGates );
     for ( i = 0; i < pLib->nGates; i++ )
         pLib->ppGatesName[i] = pLib->ppGates0[i];
     qsort( (void *)pLib->ppGatesName, pLib->nGates, sizeof(void *), 
             (int (*)(const void *, const void *)) Mio_LibraryCompareGatesByName );
 }

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;
 }

Functions

Function Documentation