| /**CFile**************************************************************** |
| |
| FileName [amapRead.c] |
| |
| SystemName [ABC: Logic synthesis and verification system.] |
| |
| PackageName [Technology mapper for standard cells.] |
| |
| Synopsis [] |
| |
| Author [Alan Mishchenko] |
| |
| Affiliation [UC Berkeley] |
| |
| Date [Ver. 1.0. Started - June 20, 2005.] |
| |
| Revision [$Id: amapRead.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] |
| |
| ***********************************************************************/ |
| |
| #include "amapInt.h" |
| #include "base/io/ioAbc.h" |
| |
| ABC_NAMESPACE_IMPL_START |
| |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// DECLARATIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| #define AMAP_STRING_GATE "GATE" |
| #define AMAP_STRING_PIN "PIN" |
| #define AMAP_STRING_NONINV "NONINV" |
| #define AMAP_STRING_INV "INV" |
| #define AMAP_STRING_UNKNOWN "UNKNOWN" |
| |
| // these symbols (and no other) can appear in the formulas |
| #define AMAP_SYMB_AND '*' |
| #define AMAP_SYMB_AND2 '&' |
| #define AMAP_SYMB_OR1 '+' |
| #define AMAP_SYMB_OR2 '|' |
| #define AMAP_SYMB_XOR '^' |
| #define AMAP_SYMB_NOT '!' |
| #define AMAP_SYMB_AFTNOT '\'' |
| #define AMAP_SYMB_OPEN '(' |
| #define AMAP_SYMB_CLOSE ')' |
| |
| typedef enum { |
| AMAP_PHASE_UNKNOWN, |
| AMAP_PHASE_INV, |
| AMAP_PHASE_NONINV |
| } Amap_PinPhase_t; |
| |
| static inline Amap_Gat_t * Amap_ParseGateAlloc( Aig_MmFlex_t * p, int nPins ) |
| { return (Amap_Gat_t *)Aig_MmFlexEntryFetch( p, sizeof(Amap_Gat_t)+sizeof(Amap_Pin_t)*nPins ); } |
| static inline char * Amap_ParseStrsav( Aig_MmFlex_t * p, char * pStr ) |
| { return pStr ? strcpy(Aig_MmFlexEntryFetch(p, strlen(pStr)+1), pStr) : NULL; } |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// FUNCTION DEFINITIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| /**Function************************************************************* |
| |
| Synopsis [Loads the file into temporary buffer.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| char * Amap_LoadFile( char * pFileName ) |
| { |
| // extern FILE * Io_FileOpen( const char * FileName, const char * PathVar, const char * Mode, int fVerbose ); |
| FILE * pFile; |
| char * pBuffer; |
| int nFileSize; |
| int RetValue; |
| // open the BLIF file for binary reading |
| pFile = Io_FileOpen( pFileName, "open_path", "rb", 1 ); |
| // pFile = fopen( FileName, "rb" ); |
| // if we got this far, file should be okay otherwise would |
| // have been detected by caller |
| if ( pFile == NULL ) |
| { |
| printf( "Cannot open file \"%s\".\n", pFileName ); |
| return NULL; |
| } |
| 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'; |
| strcat( pBuffer, "\n.end\n" ); |
| // close file |
| fclose( pFile ); |
| return pBuffer; |
| } |
| |
| /**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 [] |
| |
| ***********************************************************************/ |
| void Amap_RemoveComments( char * pBuffer, int * pnDots, int * pnLines ) |
| { |
| 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; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Splits the stream into tokens.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| Vec_Ptr_t * Amap_DeriveTokens( char * pBuffer ) |
| { |
| Vec_Ptr_t * vTokens; |
| char * pToken; |
| vTokens = Vec_PtrAlloc( 1000 ); |
| pToken = strtok( pBuffer, " =\t\r\n" ); |
| while ( pToken ) |
| { |
| Vec_PtrPush( vTokens, pToken ); |
| pToken = strtok( NULL, " =\t\r\n" ); |
| // skip latches |
| if ( pToken && strcmp( pToken, "LATCH" ) == 0 ) |
| while ( pToken && strcmp( pToken, "GATE" ) != 0 ) |
| pToken = strtok( NULL, " =\t\r\n" ); |
| } |
| return vTokens; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Finds the number of pins.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| int Amap_ParseCountPins( Vec_Ptr_t * vTokens, int iPos ) |
| { |
| char * pToken; |
| int i, Counter = 0; |
| Vec_PtrForEachEntryStart( char *, vTokens, pToken, i, iPos ) |
| if ( !strcmp( pToken, AMAP_STRING_PIN ) ) |
| Counter++; |
| else if ( !strcmp( pToken, AMAP_STRING_GATE ) ) |
| return Counter; |
| return Counter; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Collect the pin names used in the formula.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| int Amap_GateCollectNames( Aig_MmFlex_t * pMem, char * pForm, char * pPinNames[] ) |
| { |
| char Buffer[1000]; |
| char * pTemp; |
| int nPins, i; |
| // save the formula as it was |
| strcpy( Buffer, pForm ); |
| // remove the non-name symbols |
| for ( pTemp = Buffer; *pTemp; pTemp++ ) |
| if ( *pTemp == AMAP_SYMB_AND || *pTemp == AMAP_SYMB_OR1 || *pTemp == AMAP_SYMB_OR2 |
| || *pTemp == AMAP_SYMB_XOR || *pTemp == AMAP_SYMB_NOT || *pTemp == AMAP_SYMB_OPEN |
| || *pTemp == AMAP_SYMB_CLOSE || *pTemp == AMAP_SYMB_AFTNOT || *pTemp == AMAP_SYMB_AND2 ) |
| *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++] = Amap_ParseStrsav( pMem, pTemp ); |
| } |
| // get the next name |
| pTemp = strtok( NULL, " " ); |
| } |
| return nPins; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Creates a duplicate gate with pins specified.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| Amap_Gat_t * Amap_ParseGateWithSamePins( Amap_Gat_t * p ) |
| { |
| Amap_Gat_t * pGate; |
| Amap_Pin_t * pPin; |
| char * pPinNames[128]; |
| int nPinNames; |
| assert( p->nPins == 1 && !strcmp( p->Pins->pName, "*" ) ); |
| nPinNames = Amap_GateCollectNames( p->pLib->pMemGates, p->pForm, pPinNames ); |
| pGate = Amap_ParseGateAlloc( p->pLib->pMemGates, nPinNames ); |
| *pGate = *p; |
| pGate->nPins = nPinNames; |
| Amap_GateForEachPin( pGate, pPin ) |
| { |
| *pPin = *p->Pins; |
| pPin->pName = pPinNames[pPin - pGate->Pins]; |
| } |
| return pGate; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| int Amap_CollectFormulaTokens( Vec_Ptr_t * vTokens, char * pToken, int iPos ) |
| { |
| char * pNext, * pPrev; |
| pPrev = pToken + strlen(pToken); |
| while ( *(pPrev-1) != ';' ) |
| { |
| *pPrev++ = ' '; |
| pNext = (char *)Vec_PtrEntry(vTokens, iPos++); |
| while ( *pNext ) |
| *pPrev++ = *pNext++; |
| } |
| *(pPrev-1) = 0; |
| return iPos; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| Amap_Lib_t * Amap_ParseTokens( Vec_Ptr_t * vTokens, int fVerbose ) |
| { |
| Amap_Lib_t * p; |
| Amap_Gat_t * pGate, * pPrev; |
| Amap_Pin_t * pPin; |
| char * pToken, * pMoGate = NULL; |
| int i, nPins, iPos = 0, Count = 0; |
| p = Amap_LibAlloc(); |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| do |
| { |
| if ( strcmp( pToken, AMAP_STRING_GATE ) ) |
| { |
| Amap_LibFree( p ); |
| printf( "The first line should begin with %s.\n", AMAP_STRING_GATE ); |
| return NULL; |
| } |
| // start gate |
| nPins = Amap_ParseCountPins( vTokens, iPos ); |
| pGate = Amap_ParseGateAlloc( p->pMemGates, nPins ); |
| memset( pGate, 0, sizeof(Amap_Gat_t) ); |
| pGate->Id = Vec_PtrSize( p->vGates ); |
| Vec_PtrPush( p->vGates, pGate ); |
| pGate->pLib = p; |
| pGate->nPins = nPins; |
| // read gate |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| pGate->pName = Amap_ParseStrsav( p->pMemGates, pToken ); |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| pGate->dArea = atof( pToken ); |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| pGate->pOutName = Amap_ParseStrsav( p->pMemGates, pToken ); |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| iPos = Amap_CollectFormulaTokens( vTokens, pToken, iPos ); |
| pGate->pForm = Amap_ParseStrsav( p->pMemGates, pToken ); |
| // read pins |
| Amap_GateForEachPin( pGate, pPin ) |
| { |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| if ( strcmp( pToken, AMAP_STRING_PIN ) ) |
| { |
| Amap_LibFree( p ); |
| printf( "Cannot parse gate %s.\n", pGate->pName ); |
| return NULL; |
| } |
| // read pin |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| pPin->pName = Amap_ParseStrsav( p->pMemGates, pToken ); |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| if ( strcmp( pToken, AMAP_STRING_UNKNOWN ) == 0 ) |
| pPin->Phase = AMAP_PHASE_UNKNOWN; |
| else if ( strcmp( pToken, AMAP_STRING_INV ) == 0 ) |
| pPin->Phase = AMAP_PHASE_INV; |
| else if ( strcmp( pToken, AMAP_STRING_NONINV ) == 0 ) |
| pPin->Phase = AMAP_PHASE_NONINV; |
| else |
| { |
| Amap_LibFree( p ); |
| printf( "Cannot read phase of pin %s of gate %s\n", pPin->pName, pGate->pName ); |
| return NULL; |
| } |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| pPin->dLoadInput = atof( pToken ); |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| pPin->dLoadMax = atof( pToken ); |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| pPin->dDelayBlockRise = atof( pToken ); |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| pPin->dDelayFanoutRise = atof( pToken ); |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| pPin->dDelayBlockFall = atof( pToken ); |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| pPin->dDelayFanoutFall = atof( pToken ); |
| if ( pPin->dDelayBlockRise > pPin->dDelayBlockFall ) |
| pPin->dDelayBlockMax = pPin->dDelayBlockRise; |
| else |
| pPin->dDelayBlockMax = pPin->dDelayBlockFall; |
| } |
| // fix the situation when all pins are represented as one |
| if ( pGate->nPins == 1 && !strcmp( pGate->Pins->pName, "*" ) ) |
| { |
| pGate = Amap_ParseGateWithSamePins( pGate ); |
| Vec_PtrPop( p->vGates ); |
| Vec_PtrPush( p->vGates, pGate ); |
| } |
| pToken = (char *)Vec_PtrEntry(vTokens, iPos++); |
| //printf( "Finished reading gate %s (%s)\n", pGate->pName, pGate->pOutName ); |
| } |
| while ( strcmp( pToken, ".end" ) ); |
| |
| // check if there are gates with identical names |
| pPrev = NULL; |
| Amap_LibForEachGate( p, pGate, i ) |
| { |
| if ( pPrev && !strcmp(pPrev->pName, pGate->pName) ) |
| { |
| pPrev->pTwin = pGate, pGate->pTwin = pPrev; |
| // printf( "Warning: Detected multi-output gate \"%s\".\n", pGate->pName ); |
| if ( pMoGate == NULL ) |
| pMoGate = pGate->pName; |
| Count++; |
| } |
| pPrev = pGate; |
| } |
| if ( Count ) |
| printf( "Warning: Detected %d multi-output gates (for example, \"%s\").\n", Count, pMoGate ); |
| return p; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Reads the library from the input file.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| Amap_Lib_t * Amap_LibReadBuffer( char * pBuffer, int fVerbose ) |
| { |
| Amap_Lib_t * pLib; |
| Vec_Ptr_t * vTokens; |
| Amap_RemoveComments( pBuffer, NULL, NULL ); |
| vTokens = Amap_DeriveTokens( pBuffer ); |
| pLib = Amap_ParseTokens( vTokens, fVerbose ); |
| if ( pLib == NULL ) |
| { |
| Vec_PtrFree( vTokens ); |
| return NULL; |
| } |
| Vec_PtrFree( vTokens ); |
| return pLib; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Reads the library from the input file.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| Amap_Lib_t * Amap_LibReadFile( char * pFileName, int fVerbose ) |
| { |
| Amap_Lib_t * pLib; |
| char * pBuffer; |
| pBuffer = Amap_LoadFile( pFileName ); |
| if ( pBuffer == NULL ) |
| return NULL; |
| pLib = Amap_LibReadBuffer( pBuffer, fVerbose ); |
| if ( pLib ) |
| pLib->pName = Abc_UtilStrsav( pFileName ); |
| ABC_FREE( pBuffer ); |
| return pLib; |
| } |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// END OF FILE /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| |
| ABC_NAMESPACE_IMPL_END |
| |
