| /**CFile**************************************************************** |
| |
| FileName [ioReadBlifMv.c] |
| |
| SystemName [ABC: Logic synthesis and verification system.] |
| |
| PackageName [Command processing package.] |
| |
| Synopsis [Procedures to read BLIF-MV file.] |
| |
| Author [Alan Mishchenko] |
| |
| Affiliation [UC Berkeley] |
| |
| Date [Ver. 1.0. Started - January 8, 2007.] |
| |
| Revision [$Id: ioReadBlifMv.c,v 1.00 2007/01/08 00:00:00 alanmi Exp $] |
| |
| ***********************************************************************/ |
| |
| #include "misc/zlib/zlib.h" |
| #include "misc/bzlib/bzlib.h" |
| #include "base/abc/abc.h" |
| #include "misc/vec/vecPtr.h" |
| #include "ioAbc.h" |
| |
| ABC_NAMESPACE_IMPL_START |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// DECLARATIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| #define IO_BLIFMV_MAXVALUES 256 |
| //#define IO_VERBOSE_OUTPUT |
| |
| typedef struct Io_MvVar_t_ Io_MvVar_t; // parsing var |
| typedef struct Io_MvMod_t_ Io_MvMod_t; // parsing model |
| typedef struct Io_MvMan_t_ Io_MvMan_t; // parsing manager |
| |
| Vec_Ptr_t *vGlobalLtlArray; |
| |
| struct Io_MvVar_t_ |
| { |
| int nValues; // the number of values |
| char ** pNames; // the value names |
| }; |
| |
| struct Io_MvMod_t_ |
| { |
| // file lines |
| char * pName; // .model line |
| Vec_Ptr_t * vInputs; // .inputs lines |
| Vec_Ptr_t * vOutputs; // .outputs lines |
| Vec_Ptr_t * vLatches; // .latch lines |
| Vec_Ptr_t * vFlops; // .flop lines |
| Vec_Ptr_t * vResets; // .reset lines |
| Vec_Ptr_t * vNames; // .names lines |
| Vec_Ptr_t * vSubckts; // .subckt lines |
| Vec_Ptr_t * vShorts; // .short lines |
| Vec_Ptr_t * vOnehots; // .onehot lines |
| Vec_Ptr_t * vMvs; // .mv lines |
| Vec_Ptr_t * vConstrs; // .constraint lines |
| Vec_Ptr_t * vLtlProperties; |
| int fBlackBox; // indicates blackbox model |
| // the resulting network |
| Abc_Ntk_t * pNtk; |
| Abc_Obj_t * pResetLatch; |
| // the parent manager |
| Io_MvMan_t * pMan; |
| }; |
| |
| struct Io_MvMan_t_ |
| { |
| // general info about file |
| int fBlifMv; // the file is BLIF-MV |
| int fUseReset; // the reset circuitry is added |
| char * pFileName; // the name of the file |
| char * pBuffer; // the contents of the file |
| Vec_Ptr_t * vLines; // the line beginnings |
| // the results of reading |
| Abc_Des_t * pDesign; // the design under construction |
| int nNDnodes; // the counter of ND nodes |
| // intermediate storage for models |
| Vec_Ptr_t * vModels; // vector of models |
| Io_MvMod_t * pLatest; // the current model |
| // current processing info |
| Vec_Ptr_t * vTokens; // the current tokens |
| Vec_Ptr_t * vTokens2; // the current tokens |
| Vec_Str_t * vFunc; // the local function |
| // error reporting |
| char sError[512]; // the error string generated during parsing |
| // statistics |
| int nTablesRead; // the number of processed tables |
| int nTablesLeft; // the number of dangling tables |
| }; |
| |
| // static functions |
| static Io_MvMan_t * Io_MvAlloc(); |
| static void Io_MvFree( Io_MvMan_t * p ); |
| static Io_MvMod_t * Io_MvModAlloc(); |
| static void Io_MvModFree( Io_MvMod_t * p ); |
| static char * Io_MvLoadFile( char * pFileName ); |
| static void Io_MvReadPreparse( Io_MvMan_t * p ); |
| static int Io_MvReadInterfaces( Io_MvMan_t * p ); |
| static Abc_Des_t * Io_MvParse( Io_MvMan_t * p ); |
| static int Io_MvParseLineModel( Io_MvMod_t * p, char * pLine ); |
| static int Io_MvParseLineInputs( Io_MvMod_t * p, char * pLine ); |
| static int Io_MvParseLineOutputs( Io_MvMod_t * p, char * pLine ); |
| static int Io_MvParseLineConstrs( Io_MvMod_t * p, char * pLine ); |
| static int Io_MvParseLineLatch( Io_MvMod_t * p, char * pLine ); |
| static int Io_MvParseLineFlop( Io_MvMod_t * p, char * pLine ); |
| static int Io_MvParseLineSubckt( Io_MvMod_t * p, char * pLine ); |
| static Vec_Int_t * Io_MvParseLineOnehot( Io_MvMod_t * p, char * pLine ); |
| static int Io_MvParseLineMv( Io_MvMod_t * p, char * pLine ); |
| static int Io_MvParseLineNamesMv( Io_MvMod_t * p, char * pLine, int fReset ); |
| static int Io_MvParseLineNamesBlif( Io_MvMod_t * p, char * pLine ); |
| static int Io_MvParseLineShortBlif( Io_MvMod_t * p, char * pLine ); |
| static int Io_MvParseLineLtlProperty( Io_MvMod_t * p, char * pLine ); |
| static int Io_MvParseLineGateBlif( Io_MvMod_t * p, Vec_Ptr_t * vTokens ); |
| static Io_MvVar_t * Abc_NtkMvVarDup( Abc_Ntk_t * pNtk, Io_MvVar_t * pVar ); |
| |
| static int Io_MvCharIsSpace( char s ) { return s == ' ' || s == '\t' || s == '\r' || s == '\n'; } |
| static int Io_MvCharIsMvSymb( char s ) { return s == '(' || s == ')' || s == '{' || s == '}' || s == '-' || s == ',' || s == '!'; } |
| |
| extern void Abc_NtkStartMvVars( Abc_Ntk_t * pNtk ); |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// FUNCTION DEFINITIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| /**Function************************************************************* |
| |
| Synopsis [Reads the network from the BLIF or BLIF-MV file.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| Abc_Ntk_t * Io_ReadBlifMv( char * pFileName, int fBlifMv, int fCheck ) |
| { |
| FILE * pFile; |
| Io_MvMan_t * p; |
| Abc_Ntk_t * pNtk, * pExdc; |
| Abc_Des_t * pDesign = NULL; |
| char * pDesignName; |
| int RetValue, i; |
| char * pLtlProp; |
| |
| // check that the file is available |
| pFile = fopen( pFileName, "rb" ); |
| if ( pFile == NULL ) |
| { |
| printf( "Io_ReadBlifMv(): The file is unavailable (absent or open).\n" ); |
| return 0; |
| } |
| fclose( pFile ); |
| |
| // start the file reader |
| p = Io_MvAlloc(); |
| p->fBlifMv = fBlifMv; |
| p->fUseReset = 1; |
| p->pFileName = pFileName; |
| p->pBuffer = Io_MvLoadFile( pFileName ); |
| if ( p->pBuffer == NULL ) |
| { |
| Io_MvFree( p ); |
| return NULL; |
| } |
| // set the design name |
| pDesignName = Extra_FileNameGeneric( pFileName ); |
| p->pDesign = Abc_DesCreate( pDesignName ); |
| ABC_FREE( pDesignName ); |
| // free the HOP manager |
| Hop_ManStop( (Hop_Man_t *)p->pDesign->pManFunc ); |
| p->pDesign->pManFunc = NULL; |
| // prepare the file for parsing |
| Io_MvReadPreparse( p ); |
| // parse interfaces of each network and construct the network |
| if ( Io_MvReadInterfaces( p ) ) |
| pDesign = Io_MvParse( p ); |
| if ( p->sError[0] ) |
| fprintf( stdout, "%s\n", p->sError ); |
| Io_MvFree( p ); |
| if ( pDesign == NULL ) |
| return NULL; |
| // pDesign should be linked to all models of the design |
| |
| // make sure that everything is okay with the network structure |
| if ( fCheck ) |
| { |
| Vec_PtrForEachEntry( Abc_Ntk_t *, pDesign->vModules, pNtk, i ) |
| { |
| if ( !Abc_NtkCheckRead( pNtk ) ) |
| { |
| printf( "Io_ReadBlifMv: The network check has failed for model %s.\n", pNtk->pName ); |
| Abc_DesFree( pDesign, NULL ); |
| return NULL; |
| } |
| } |
| } |
| |
| //Abc_DesPrint( pDesign ); |
| |
| // check if there is an EXDC network |
| if ( Vec_PtrSize(pDesign->vModules) > 1 ) |
| { |
| pNtk = (Abc_Ntk_t *)Vec_PtrEntry(pDesign->vModules, 0); |
| Vec_PtrForEachEntryStart( Abc_Ntk_t *, pDesign->vModules, pExdc, i, 1 ) |
| if ( !strcmp(pExdc->pName, "EXDC") ) |
| { |
| assert( pNtk->pExdc == NULL ); |
| pNtk->pExdc = pExdc; |
| Vec_PtrRemove(pDesign->vModules, pExdc); |
| pExdc->pDesign = NULL; |
| i--; |
| } |
| else |
| pNtk = pExdc; |
| } |
| |
| // detect top-level model |
| RetValue = Abc_DesFindTopLevelModels( pDesign ); |
| pNtk = (Abc_Ntk_t *)Vec_PtrEntry( pDesign->vTops, 0 ); |
| if ( RetValue > 1 ) |
| printf( "Warning: The design has %d root-level modules. The first one (%s) will be used.\n", |
| Vec_PtrSize(pDesign->vTops), pNtk->pName ); |
| |
| // extract the master network |
| pNtk->pDesign = pDesign; |
| pDesign->pManFunc = NULL; |
| |
| // verify the design for cyclic dependence |
| assert( Vec_PtrSize(pDesign->vModules) > 0 ); |
| if ( Vec_PtrSize(pDesign->vModules) == 1 ) |
| { |
| // printf( "Warning: The design is not hierarchical.\n" ); |
| Abc_DesFree( pDesign, pNtk ); |
| pNtk->pDesign = NULL; |
| pNtk->pSpec = Extra_UtilStrsav( pFileName ); |
| } |
| else |
| Abc_NtkIsAcyclicHierarchy( pNtk ); |
| |
| //Io_WriteBlifMv( pNtk, "_temp_.mv" ); |
| if ( pNtk->pSpec == NULL ) |
| pNtk->pSpec = Extra_UtilStrsav( pFileName ); |
| |
| vGlobalLtlArray = Vec_PtrAlloc( 100 ); |
| Vec_PtrForEachEntry( char *, vGlobalLtlArray, pLtlProp, i ) |
| Vec_PtrPush( pNtk->vLtlProperties, pLtlProp ); |
| Vec_PtrFreeP( &vGlobalLtlArray ); |
| return pNtk; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Allocates the BLIF parsing structure.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static Io_MvMan_t * Io_MvAlloc() |
| { |
| Io_MvMan_t * p; |
| p = ABC_ALLOC( Io_MvMan_t, 1 ); |
| memset( p, 0, sizeof(Io_MvMan_t) ); |
| p->vLines = Vec_PtrAlloc( 512 ); |
| p->vModels = Vec_PtrAlloc( 512 ); |
| p->vTokens = Vec_PtrAlloc( 512 ); |
| p->vTokens2 = Vec_PtrAlloc( 512 ); |
| p->vFunc = Vec_StrAlloc( 512 ); |
| return p; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Frees the BLIF parsing structure.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static void Io_MvFree( Io_MvMan_t * p ) |
| { |
| Io_MvMod_t * pMod; |
| int i; |
| if ( p->pDesign ) |
| Abc_DesFree( p->pDesign, NULL ); |
| if ( p->pBuffer ) |
| ABC_FREE( p->pBuffer ); |
| if ( p->vLines ) |
| Vec_PtrFree( p->vLines ); |
| if ( p->vModels ) |
| { |
| Vec_PtrForEachEntry( Io_MvMod_t *, p->vModels, pMod, i ) |
| Io_MvModFree( pMod ); |
| Vec_PtrFree( p->vModels ); |
| } |
| Vec_PtrFree( p->vTokens ); |
| Vec_PtrFree( p->vTokens2 ); |
| Vec_StrFree( p->vFunc ); |
| ABC_FREE( p ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Allocates the BLIF parsing structure for one model.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static Io_MvMod_t * Io_MvModAlloc() |
| { |
| Io_MvMod_t * p; |
| p = ABC_ALLOC( Io_MvMod_t, 1 ); |
| memset( p, 0, sizeof(Io_MvMod_t) ); |
| p->vInputs = Vec_PtrAlloc( 512 ); |
| p->vOutputs = Vec_PtrAlloc( 512 ); |
| p->vLatches = Vec_PtrAlloc( 512 ); |
| p->vFlops = Vec_PtrAlloc( 512 ); |
| p->vResets = Vec_PtrAlloc( 512 ); |
| p->vNames = Vec_PtrAlloc( 512 ); |
| p->vSubckts = Vec_PtrAlloc( 512 ); |
| p->vShorts = Vec_PtrAlloc( 512 ); |
| p->vOnehots = Vec_PtrAlloc( 512 ); |
| p->vMvs = Vec_PtrAlloc( 512 ); |
| p->vConstrs = Vec_PtrAlloc( 512 ); |
| p->vLtlProperties = Vec_PtrAlloc( 512 ); |
| return p; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Allocates the BLIF parsing structure for one model.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static void Io_MvModFree( Io_MvMod_t * p ) |
| { |
| // if ( p->pNtk ) |
| // Abc_NtkDelete( p->pNtk ); |
| Vec_PtrFree( p->vLtlProperties ); |
| Vec_PtrFree( p->vInputs ); |
| Vec_PtrFree( p->vOutputs ); |
| Vec_PtrFree( p->vLatches ); |
| Vec_PtrFree( p->vFlops ); |
| Vec_PtrFree( p->vResets ); |
| Vec_PtrFree( p->vNames ); |
| Vec_PtrFree( p->vSubckts ); |
| Vec_PtrFree( p->vShorts ); |
| Vec_PtrFree( p->vOnehots ); |
| Vec_PtrFree( p->vMvs ); |
| Vec_PtrFree( p->vConstrs ); |
| ABC_FREE( p ); |
| } |
| |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [Counts the number of given chars.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvCountChars( char * pLine, char Char ) |
| { |
| char * pCur; |
| int Counter = 0; |
| for ( pCur = pLine; *pCur; pCur++ ) |
| if ( *pCur == Char ) |
| Counter++; |
| return Counter; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Returns the place where the arrow is hiding.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static char * Io_MvFindArrow( char * pLine ) |
| { |
| char * pCur; |
| for ( pCur = pLine; *(pCur+1); pCur++ ) |
| if ( *pCur == '-' && *(pCur+1) == '>' ) |
| { |
| *pCur = ' '; |
| *(pCur+1) = ' '; |
| return pCur; |
| } |
| return NULL; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Collects the already split tokens.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static void Io_MvCollectTokens( Vec_Ptr_t * vTokens, char * pInput, char * pOutput ) |
| { |
| char * pCur; |
| Vec_PtrClear( vTokens ); |
| for ( pCur = pInput; pCur < pOutput; pCur++ ) |
| { |
| if ( *pCur == 0 ) |
| continue; |
| Vec_PtrPush( vTokens, pCur ); |
| while ( *++pCur ); |
| } |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Splits the line into tokens.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static void Io_MvSplitIntoTokens( Vec_Ptr_t * vTokens, char * pLine, char Stop ) |
| { |
| char * pCur; |
| // clear spaces |
| for ( pCur = pLine; *pCur != Stop; pCur++ ) |
| if ( Io_MvCharIsSpace(*pCur) ) |
| *pCur = 0; |
| // collect tokens |
| Io_MvCollectTokens( vTokens, pLine, pCur ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Splits the line into tokens when .default may be present.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static void Io_MvSplitIntoTokensMv( Vec_Ptr_t * vTokens, char * pLine ) |
| { |
| char * pCur; |
| // clear spaces |
| for ( pCur = pLine; *pCur != '.' || *(pCur+1) == 'd'; pCur++ ) |
| if ( Io_MvCharIsSpace(*pCur) ) |
| *pCur = 0; |
| // collect tokens |
| Io_MvCollectTokens( vTokens, pLine, pCur ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Splits the line into tokens.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static void Io_MvSplitIntoTokensAndClear( Vec_Ptr_t * vTokens, char * pLine, char Stop, char Char ) |
| { |
| char * pCur; |
| // clear spaces |
| for ( pCur = pLine; *pCur != Stop; pCur++ ) |
| if ( Io_MvCharIsSpace(*pCur) || *pCur == Char ) |
| *pCur = 0; |
| // collect tokens |
| Io_MvCollectTokens( vTokens, pLine, pCur ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Returns the 1-based number of the line in which the token occurs.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvGetLine( Io_MvMan_t * p, char * pToken ) |
| { |
| char * pLine; |
| int i; |
| Vec_PtrForEachEntry( char *, p->vLines, pLine, i ) |
| if ( pToken < pLine ) |
| return i; |
| return -1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Reads the file into a character buffer.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| typedef struct buflist { |
| char buf[1<<20]; |
| int nBuf; |
| struct buflist * next; |
| } buflist; |
| |
| char * Io_MvLoadFileBz2( char * pFileName, int * pnFileSize ) |
| { |
| FILE * pFile; |
| int nFileSize = 0; |
| char * pContents; |
| BZFILE * b; |
| int bzError, RetValue; |
| struct buflist * pNext; |
| buflist * bufHead = NULL, * buf = NULL; |
| |
| pFile = fopen( pFileName, "rb" ); |
| if ( pFile == NULL ) |
| { |
| Abc_Print( -1, "Io_MvLoadFileBz2(): The file is unavailable (absent or open).\n" ); |
| return NULL; |
| } |
| b = BZ2_bzReadOpen(&bzError,pFile,0,0,NULL,0); |
| if (bzError != BZ_OK) { |
| Abc_Print( -1, "Io_MvLoadFileBz2(): BZ2_bzReadOpen() failed with error %d.\n",bzError ); |
| return NULL; |
| } |
| do { |
| if (!bufHead) |
| buf = bufHead = ABC_ALLOC( buflist, 1 ); |
| else |
| buf = buf->next = ABC_ALLOC( buflist, 1 ); |
| nFileSize += buf->nBuf = BZ2_bzRead(&bzError,b,buf->buf,1<<20); |
| buf->next = NULL; |
| } while (bzError == BZ_OK); |
| if (bzError == BZ_STREAM_END) { |
| // we're okay |
| char * p; |
| int nBytes = 0; |
| BZ2_bzReadClose(&bzError,b); |
| p = pContents = ABC_ALLOC( char, nFileSize + 10 ); |
| buf = bufHead; |
| do { |
| memcpy(p+nBytes,buf->buf,buf->nBuf); |
| nBytes += buf->nBuf; |
| // } while((buf = buf->next)); |
| pNext = buf->next; |
| ABC_FREE( buf ); |
| } while((buf = pNext)); |
| } else if (bzError == BZ_DATA_ERROR_MAGIC) { |
| // not a BZIP2 file |
| BZ2_bzReadClose(&bzError,b); |
| fseek( pFile, 0, SEEK_END ); |
| nFileSize = ftell( pFile ); |
| if ( nFileSize == 0 ) |
| { |
| Abc_Print( -1, "Io_MvLoadFileBz2(): The file is empty.\n" ); |
| return NULL; |
| } |
| pContents = ABC_ALLOC( char, nFileSize + 10 ); |
| rewind( pFile ); |
| RetValue = fread( pContents, nFileSize, 1, pFile ); |
| } else { |
| // Some other error. |
| Abc_Print( -1, "Io_MvLoadFileBz2(): Unable to read the compressed BLIF.\n" ); |
| return NULL; |
| } |
| fclose( pFile ); |
| // finish off the file with the spare .end line |
| // some benchmarks suddenly break off without this line |
| strcpy( pContents + nFileSize, "\n.end\n" ); |
| *pnFileSize = nFileSize; |
| return pContents; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Reads the file into a character buffer.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static char * Io_MvLoadFileGz( char * pFileName, int * pnFileSize ) |
| { |
| const int READ_BLOCK_SIZE = 100000; |
| gzFile pFile; |
| char * pContents; |
| int amtRead, readBlock, nFileSize = READ_BLOCK_SIZE; |
| pFile = gzopen( pFileName, "rb" ); // if pFileName doesn't end in ".gz" then this acts as a passthrough to fopen |
| pContents = ABC_ALLOC( char, nFileSize ); |
| readBlock = 0; |
| while ((amtRead = gzread(pFile, pContents + readBlock * READ_BLOCK_SIZE, READ_BLOCK_SIZE)) == READ_BLOCK_SIZE) { |
| //Abc_Print( 1,"%d: read %d bytes\n", readBlock, amtRead); |
| nFileSize += READ_BLOCK_SIZE; |
| pContents = ABC_REALLOC(char, pContents, nFileSize); |
| ++readBlock; |
| } |
| //Abc_Print( 1,"%d: read %d bytes\n", readBlock, amtRead); |
| assert( amtRead != -1 ); // indicates a zlib error |
| nFileSize -= (READ_BLOCK_SIZE - amtRead); |
| gzclose(pFile); |
| *pnFileSize = nFileSize; |
| return pContents; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Reads the file into a character buffer.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static char * Io_MvLoadFile( char * pFileName ) |
| { |
| FILE * pFile; |
| int nFileSize; |
| char * pContents; |
| int RetValue; |
| if ( !strncmp(pFileName+strlen(pFileName)-4,".bz2",4) ) |
| return Io_MvLoadFileBz2( pFileName, &nFileSize ); |
| if ( !strncmp(pFileName+strlen(pFileName)-3,".gz",3) ) |
| return Io_MvLoadFileGz( pFileName, &nFileSize ); |
| pFile = fopen( pFileName, "rb" ); |
| if ( pFile == NULL ) |
| { |
| printf( "Io_MvLoadFile(): The file is unavailable (absent or open).\n" ); |
| return NULL; |
| } |
| fseek( pFile, 0, SEEK_END ); |
| nFileSize = ftell( pFile ); |
| if ( nFileSize == 0 ) |
| { |
| fclose( pFile ); |
| printf( "Io_MvLoadFile(): The file is empty.\n" ); |
| return NULL; |
| } |
| pContents = ABC_ALLOC( char, nFileSize + 10 ); |
| rewind( pFile ); |
| RetValue = fread( pContents, nFileSize, 1, pFile ); |
| fclose( pFile ); |
| // finish off the file with the spare .end line |
| // some benchmarks suddenly break off without this line |
| strcpy( pContents + nFileSize, "\n.end\n" ); |
| return pContents; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Prepares the parsing.] |
| |
| Description [Performs several preliminary operations: |
| - Cuts the file buffer into separate lines. |
| - Removes comments and line extenders. |
| - Sorts lines by directives. |
| - Estimates the number of objects. |
| - Allocates room for the objects. |
| - Allocates room for the hash table.] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static void Io_MvReadPreparse( Io_MvMan_t * p ) |
| { |
| char * pCur, * pPrev; |
| int i, fComment = 0; |
| // parse the buffer into lines and remove comments |
| Vec_PtrPush( p->vLines, p->pBuffer ); |
| for ( pCur = p->pBuffer; *pCur; pCur++ ) |
| { |
| if ( *pCur == '\n' ) |
| { |
| *pCur = 0; |
| // if ( *(pCur-1) == '\r' ) |
| // *(pCur-1) = 0; |
| fComment = 0; |
| Vec_PtrPush( p->vLines, pCur + 1 ); |
| } |
| else if ( *pCur == '#' ) |
| fComment = 1; |
| // remove comments |
| if ( fComment ) |
| *pCur = 0; |
| } |
| |
| // unfold the line extensions and sort lines by directive |
| Vec_PtrForEachEntry( char *, p->vLines, pCur, i ) |
| { |
| if ( *pCur == 0 ) |
| continue; |
| // find previous non-space character |
| for ( pPrev = pCur - 2; pPrev >= p->pBuffer; pPrev-- ) |
| if ( !Io_MvCharIsSpace(*pPrev) ) |
| break; |
| // if it is the line extender, overwrite it with spaces |
| if ( pPrev >= p->pBuffer && *pPrev == '\\' ) |
| { |
| for ( ; *pPrev; pPrev++ ) |
| *pPrev = ' '; |
| *pPrev = ' '; |
| continue; |
| } |
| // skip spaces at the beginning of the line |
| while ( Io_MvCharIsSpace(*pCur++) ); |
| // parse directives |
| if ( *(pCur-1) != '.' ) |
| continue; |
| if ( !strncmp(pCur, "names", 5) || !strncmp(pCur, "table", 5) || !strncmp(pCur, "gate", 4) ) |
| Vec_PtrPush( p->pLatest->vNames, pCur ); |
| else if ( p->fBlifMv && (!strncmp(pCur, "def ", 4) || !strncmp(pCur, "default ", 8)) ) |
| continue; |
| else if ( !strncmp( pCur, "ltlformula", 10 ) ) |
| Vec_PtrPush( p->pLatest->vLtlProperties, pCur ); |
| else if ( !strncmp(pCur, "latch", 5) ) |
| Vec_PtrPush( p->pLatest->vLatches, pCur ); |
| else if ( !strncmp(pCur, "flop", 4) ) |
| Vec_PtrPush( p->pLatest->vFlops, pCur ); |
| else if ( !strncmp(pCur, "r ", 2) || !strncmp(pCur, "reset ", 6) ) |
| Vec_PtrPush( p->pLatest->vResets, pCur ); |
| else if ( !strncmp(pCur, "inputs", 6) ) |
| Vec_PtrPush( p->pLatest->vInputs, pCur ); |
| else if ( !strncmp(pCur, "outputs", 7) ) |
| Vec_PtrPush( p->pLatest->vOutputs, pCur ); |
| else if ( !strncmp(pCur, "subckt", 6) ) |
| Vec_PtrPush( p->pLatest->vSubckts, pCur ); |
| else if ( !strncmp(pCur, "short", 5) ) |
| Vec_PtrPush( p->pLatest->vShorts, pCur ); |
| else if ( !strncmp(pCur, "onehot", 6) ) |
| Vec_PtrPush( p->pLatest->vOnehots, pCur ); |
| else if ( p->fBlifMv && !strncmp(pCur, "mv", 2) ) |
| Vec_PtrPush( p->pLatest->vMvs, pCur ); |
| else if ( !strncmp(pCur, "constraint", 10) ) |
| Vec_PtrPush( p->pLatest->vConstrs, pCur ); |
| else if ( !strncmp(pCur, "blackbox", 8) ) |
| p->pLatest->fBlackBox = 1; |
| else if ( !strncmp(pCur, "model", 5) ) |
| { |
| p->pLatest = Io_MvModAlloc(); |
| p->pLatest->pName = pCur; |
| p->pLatest->pMan = p; |
| } |
| else if ( !strncmp(pCur, "end", 3) ) |
| { |
| if ( p->pLatest ) |
| Vec_PtrPush( p->vModels, p->pLatest ); |
| p->pLatest = NULL; |
| } |
| else if ( !strncmp(pCur, "exdc", 4) ) |
| { |
| // fprintf( stdout, "Line %d: The design contains EXDC network (warning only).\n", Io_MvGetLine(p, pCur) ); |
| fprintf( stdout, "Warning: The design contains EXDC network.\n" ); |
| if ( p->pLatest ) |
| Vec_PtrPush( p->vModels, p->pLatest ); |
| p->pLatest = Io_MvModAlloc(); |
| p->pLatest->pName = NULL; |
| p->pLatest->pMan = p; |
| } |
| else if ( !strncmp(pCur, "attrib", 6) ) |
| {} |
| else if ( !strncmp(pCur, "delay", 5) ) |
| {} |
| else if ( !strncmp(pCur, "input_", 6) ) |
| {} |
| else if ( !strncmp(pCur, "output_", 7) ) |
| {} |
| else if ( !strncmp(pCur, "no_merge", 8) ) |
| {} |
| else if ( !strncmp(pCur, "wd", 2) ) |
| {} |
| // else if ( !strncmp(pCur, "inouts", 6) ) |
| // {} |
| else |
| { |
| pCur--; |
| if ( pCur[strlen(pCur)-1] == '\r' ) |
| pCur[strlen(pCur)-1] = 0; |
| fprintf( stdout, "Line %d: Skipping line \"%s\".\n", Io_MvGetLine(p, pCur), pCur ); |
| } |
| } |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses interfaces of the models.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvReadInterfaces( Io_MvMan_t * p ) |
| { |
| Io_MvMod_t * pMod; |
| char * pLine; |
| int i, k, nOutsOld; |
| // iterate through the models |
| Vec_PtrForEachEntry( Io_MvMod_t *, p->vModels, pMod, i ) |
| { |
| // parse the model |
| if ( !Io_MvParseLineModel( pMod, pMod->pName ) ) |
| return 0; |
| // add model to the design |
| if ( !Abc_DesAddModel( p->pDesign, pMod->pNtk ) ) |
| { |
| sprintf( p->sError, "Line %d: Model %s is defined twice.", Io_MvGetLine(p, pMod->pName), pMod->pName ); |
| return 0; |
| } |
| // parse the inputs |
| Vec_PtrForEachEntry( char *, pMod->vInputs, pLine, k ) |
| if ( !Io_MvParseLineInputs( pMod, pLine ) ) |
| return 0; |
| // parse the outputs |
| Vec_PtrForEachEntry( char *, pMod->vOutputs, pLine, k ) |
| if ( !Io_MvParseLineOutputs( pMod, pLine ) ) |
| return 0; |
| // parse the constraints |
| nOutsOld = Abc_NtkPoNum(pMod->pNtk); |
| Vec_PtrForEachEntry( char *, pMod->vConstrs, pLine, k ) |
| if ( !Io_MvParseLineConstrs( pMod, pLine ) ) |
| return 0; |
| pMod->pNtk->nConstrs = Abc_NtkPoNum(pMod->pNtk) - nOutsOld; |
| Vec_PtrForEachEntry( char *, pMod->vLtlProperties, pLine, k ) |
| if ( !Io_MvParseLineLtlProperty( pMod, pLine ) ) |
| return 0; |
| // report the results |
| #ifdef IO_VERBOSE_OUTPUT |
| if ( Vec_PtrSize(p->vModels) > 1 ) |
| printf( "Parsed %-32s: PI =%6d PO =%6d ND =%8d FF =%6d B =%6d\n", |
| pMod->pNtk->pName, Abc_NtkPiNum(pMod->pNtk), Abc_NtkPoNum(pMod->pNtk), |
| Vec_PtrSize(pMod->vNames), Vec_PtrSize(pMod->vLatches), Vec_PtrSize(pMod->vSubckts) ); |
| #endif |
| } |
| return 1; |
| } |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static Abc_Des_t * Io_MvParse( Io_MvMan_t * p ) |
| { |
| Abc_Des_t * pDesign; |
| Io_MvMod_t * pMod; |
| char * pLine; |
| int i, k; |
| // iterate through the models |
| Vec_PtrForEachEntry( Io_MvMod_t *, p->vModels, pMod, i ) |
| { |
| #ifdef IO_VERBOSE_OUTPUT |
| if ( Vec_PtrSize(p->vModels) > 1 ) |
| printf( "Parsing model %s...\n", pMod->pNtk->pName ); |
| #endif |
| |
| // check if there any MV lines |
| if ( Vec_PtrSize(pMod->vMvs) > 0 ) |
| Abc_NtkStartMvVars( pMod->pNtk ); |
| // parse the mv lines |
| Vec_PtrForEachEntry( char *, pMod->vMvs, pLine, k ) |
| if ( !Io_MvParseLineMv( pMod, pLine ) ) |
| return NULL; |
| // if reset lines are used there should be the same number of them as latches |
| if ( Vec_PtrSize(pMod->vResets) > 0 ) |
| { |
| if ( Vec_PtrSize(pMod->vLatches) != Vec_PtrSize(pMod->vResets) ) |
| { |
| sprintf( p->sError, "Line %d: Model %s has different number of latches (%d) and reset nodes (%d).", |
| Io_MvGetLine(p, pMod->pName), Abc_NtkName(pMod->pNtk), Vec_PtrSize(pMod->vLatches), Vec_PtrSize(pMod->vResets) ); |
| return NULL; |
| } |
| // create binary latch with 1-data and 0-init |
| if ( p->fUseReset ) |
| pMod->pResetLatch = Io_ReadCreateResetLatch( pMod->pNtk, p->fBlifMv ); |
| } |
| // parse the flops |
| Vec_PtrForEachEntry( char *, pMod->vFlops, pLine, k ) |
| if ( !Io_MvParseLineFlop( pMod, pLine ) ) |
| return NULL; |
| // parse the latches |
| Vec_PtrForEachEntry( char *, pMod->vLatches, pLine, k ) |
| if ( !Io_MvParseLineLatch( pMod, pLine ) ) |
| return NULL; |
| // parse the reset lines |
| if ( p->fUseReset ) |
| Vec_PtrForEachEntry( char *, pMod->vResets, pLine, k ) |
| if ( !Io_MvParseLineNamesMv( pMod, pLine, 1 ) ) |
| return NULL; |
| // parse the nodes |
| if ( p->fBlifMv ) |
| { |
| Vec_PtrForEachEntry( char *, pMod->vNames, pLine, k ) |
| if ( !Io_MvParseLineNamesMv( pMod, pLine, 0 ) ) |
| return NULL; |
| } |
| else |
| { |
| Vec_PtrForEachEntry( char *, pMod->vNames, pLine, k ) |
| if ( !Io_MvParseLineNamesBlif( pMod, pLine ) ) |
| return NULL; |
| Vec_PtrForEachEntry( char *, pMod->vShorts, pLine, k ) |
| if ( !Io_MvParseLineShortBlif( pMod, pLine ) ) |
| return NULL; |
| } |
| // parse the subcircuits |
| Vec_PtrForEachEntry( char *, pMod->vSubckts, pLine, k ) |
| if ( !Io_MvParseLineSubckt( pMod, pLine ) ) |
| return NULL; |
| |
| // allow for blackboxes without .blackbox line |
| if ( Abc_NtkLatchNum(pMod->pNtk) == 0 && Abc_NtkNodeNum(pMod->pNtk) == 0 && Abc_NtkBoxNum(pMod->pNtk) == 0 ) |
| { |
| if ( pMod->pNtk->ntkFunc == ABC_FUNC_SOP ) |
| { |
| Mem_FlexStop( (Mem_Flex_t *)pMod->pNtk->pManFunc, 0 ); |
| pMod->pNtk->pManFunc = NULL; |
| pMod->pNtk->ntkFunc = ABC_FUNC_BLACKBOX; |
| } |
| } |
| |
| // finalize the network |
| Abc_NtkFinalizeRead( pMod->pNtk ); |
| // read the one-hotness lines |
| if ( Vec_PtrSize(pMod->vOnehots) > 0 ) |
| { |
| Vec_Int_t * vLine; |
| Abc_Obj_t * pObj; |
| // set register numbers |
| Abc_NtkForEachLatch( pMod->pNtk, pObj, k ) |
| pObj->pNext = (Abc_Obj_t *)(ABC_PTRINT_T)k; |
| // derive register |
| pMod->pNtk->vOnehots = Vec_PtrAlloc( Vec_PtrSize(pMod->vOnehots) ); |
| Vec_PtrForEachEntry( char *, pMod->vOnehots, pLine, k ) |
| { |
| vLine = Io_MvParseLineOnehot( pMod, pLine ); |
| if ( vLine == NULL ) |
| return NULL; |
| Vec_PtrPush( pMod->pNtk->vOnehots, vLine ); |
| // printf( "Parsed %d one-hot registers.\n", Vec_IntSize(vLine) ); |
| } |
| // reset register numbers |
| Abc_NtkForEachLatch( pMod->pNtk, pObj, k ) |
| pObj->pNext = NULL; |
| // print the result |
| printf( "Parsed %d groups of 1-hot registers: { ", Vec_PtrSize(pMod->pNtk->vOnehots) ); |
| Vec_PtrForEachEntry( Vec_Int_t *, pMod->pNtk->vOnehots, vLine, k ) |
| printf( "%d ", Vec_IntSize(vLine) ); |
| printf( "}\n" ); |
| printf( "The total number of 1-hot registers = %d. (%.2f %%)\n", |
| Vec_VecSizeSize( (Vec_Vec_t *)pMod->pNtk->vOnehots ), |
| 100.0 * Vec_VecSizeSize( (Vec_Vec_t *)pMod->pNtk->vOnehots ) / Abc_NtkLatchNum(pMod->pNtk) ); |
| { |
| extern void Abc_GenOneHotIntervals( char * pFileName, int nPis, int nRegs, Vec_Ptr_t * vOnehots ); |
| char * pFileName = Extra_FileNameGenericAppend( pMod->pMan->pFileName, "_1h.blif" ); |
| Abc_GenOneHotIntervals( pFileName, Abc_NtkPiNum(pMod->pNtk), Abc_NtkLatchNum(pMod->pNtk), pMod->pNtk->vOnehots ); |
| printf( "One-hotness condition is written into file \"%s\".\n", pFileName ); |
| } |
| } |
| if ( Vec_PtrSize(pMod->vFlops) ) |
| { |
| printf( "Warning: The parser converted %d .flop lines into .latch lines\n", Vec_PtrSize(pMod->vFlops) ); |
| printf( "(information about set, reset, enable of the flops may be lost).\n" ); |
| } |
| |
| } |
| if ( p->nNDnodes ) |
| // printf( "Warning: The parser added %d PIs to replace non-deterministic nodes.\n", p->nNDnodes ); |
| printf( "Warning: The parser added %d constant 0 nodes to replace non-deterministic nodes.\n", p->nNDnodes ); |
| // return the network |
| pDesign = p->pDesign; |
| p->pDesign = NULL; |
| return pDesign; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the model line.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLineModel( Io_MvMod_t * p, char * pLine ) |
| { |
| Vec_Ptr_t * vTokens = p->pMan->vTokens; |
| char * pToken, * pPivot; |
| if ( pLine == NULL ) |
| { |
| p->pNtk = Abc_NtkAlloc( ABC_NTK_NETLIST, ABC_FUNC_SOP, 1 ); |
| p->pNtk->pName = Extra_UtilStrsav( "EXDC" ); |
| return 1; |
| } |
| Io_MvSplitIntoTokens( vTokens, pLine, '\0' ); |
| pToken = (char *)Vec_PtrEntry( vTokens, 0 ); |
| assert( !strcmp(pToken, "model") ); |
| if ( Vec_PtrSize(vTokens) != 2 ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Model line has %d entries while it should have 2.", Io_MvGetLine(p->pMan, pToken), Vec_PtrSize(vTokens) ); |
| return 0; |
| } |
| if ( p->fBlackBox ) |
| p->pNtk = Abc_NtkAlloc( ABC_NTK_NETLIST, ABC_FUNC_BLACKBOX, 1 ); |
| else if ( p->pMan->fBlifMv ) |
| p->pNtk = Abc_NtkAlloc( ABC_NTK_NETLIST, ABC_FUNC_BLIFMV, 1 ); |
| else |
| p->pNtk = Abc_NtkAlloc( ABC_NTK_NETLIST, ABC_FUNC_SOP, 1 ); |
| // for ( pPivot = pToken = Vec_PtrEntry(vTokens, 1); *pToken; pToken++ ) |
| // if ( *pToken == '/' || *pToken == '\\' ) |
| // pPivot = pToken+1; |
| pPivot = pToken = (char *)Vec_PtrEntry(vTokens, 1); |
| p->pNtk->pName = Extra_UtilStrsav( pPivot ); |
| return 1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the inputs line.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLineInputs( Io_MvMod_t * p, char * pLine ) |
| { |
| Vec_Ptr_t * vTokens = p->pMan->vTokens; |
| char * pToken; |
| int i; |
| Io_MvSplitIntoTokens( vTokens, pLine, '\0' ); |
| pToken = (char *)Vec_PtrEntry(vTokens, 0); |
| assert( !strcmp(pToken, "inputs") ); |
| Vec_PtrForEachEntryStart( char *, vTokens, pToken, i, 1 ) |
| Io_ReadCreatePi( p->pNtk, pToken ); |
| return 1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the outputs line.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLineOutputs( Io_MvMod_t * p, char * pLine ) |
| { |
| Vec_Ptr_t * vTokens = p->pMan->vTokens; |
| char * pToken; |
| int i; |
| Io_MvSplitIntoTokens( vTokens, pLine, '\0' ); |
| pToken = (char *)Vec_PtrEntry(vTokens, 0); |
| assert( !strcmp(pToken, "outputs") ); |
| Vec_PtrForEachEntryStart( char *, vTokens, pToken, i, 1 ) |
| Io_ReadCreatePo( p->pNtk, pToken ); |
| return 1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the outputs line.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLineConstrs( Io_MvMod_t * p, char * pLine ) |
| { |
| Vec_Ptr_t * vTokens = p->pMan->vTokens; |
| char * pToken; |
| int i; |
| Io_MvSplitIntoTokens( vTokens, pLine, '\0' ); |
| pToken = (char *)Vec_PtrEntry(vTokens, 0); |
| assert( !strcmp(pToken, "constraint") ); |
| Vec_PtrForEachEntryStart( char *, vTokens, pToken, i, 1 ) |
| Io_ReadCreatePo( p->pNtk, pToken ); |
| return 1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the LTL property line.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLineLtlProperty( Io_MvMod_t * p, char * pLine ) |
| { |
| int i, j; |
| int quoteBegin, quoteEnd; |
| char keyWordLtlFormula[11]; |
| char *actualLtlFormula; |
| |
| //checking if the line begins with the keyword "ltlformula" and |
| //progressing the pointer forword |
| for( i=0; i<10; i++ ) |
| keyWordLtlFormula[i] = pLine[i]; |
| quoteBegin = i; |
| keyWordLtlFormula[10] = '\0'; |
| assert( strcmp( "ltlformula", keyWordLtlFormula ) == 0 ); |
| while( pLine[i] != '"' ) |
| i++; |
| quoteBegin = i; |
| i = strlen( pLine ); |
| while( pLine[i] != '"' ) |
| i--; |
| quoteEnd = i; |
| actualLtlFormula = (char *)malloc( sizeof(char) * (quoteEnd - quoteBegin) ); |
| //printf("\nThe input ltl formula = "); |
| for( i = quoteBegin + 1, j = 0; i<quoteEnd; i++, j++ ) |
| //printf("%c", pLine[i] ); |
| actualLtlFormula[j] = pLine[i]; |
| actualLtlFormula[j] = '\0'; |
| Vec_PtrPush( vGlobalLtlArray, actualLtlFormula ); |
| return 1; |
| } |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the latches line.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLineLatch( Io_MvMod_t * p, char * pLine ) |
| { |
| Vec_Ptr_t * vTokens = p->pMan->vTokens; |
| Abc_Obj_t * pObj, * pNet; |
| char * pToken; |
| int Init; |
| Io_MvSplitIntoTokens( vTokens, pLine, '\0' ); |
| pToken = (char *)Vec_PtrEntry(vTokens,0); |
| assert( !strcmp(pToken, "latch") ); |
| if ( Vec_PtrSize(vTokens) < 3 ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Latch does not have input name and output name.", Io_MvGetLine(p->pMan, pToken) ); |
| return 0; |
| } |
| // create latch |
| if ( p->pResetLatch == NULL ) |
| { |
| pObj = Io_ReadCreateLatch( p->pNtk, (char *)Vec_PtrEntry(vTokens,1), (char *)Vec_PtrEntry(vTokens,2) ); |
| // get initial value |
| if ( p->pMan->fBlifMv ) |
| Abc_LatchSetInit0( pObj ); |
| else |
| { |
| if ( Vec_PtrSize(vTokens) > 6 ) |
| printf( "Warning: Line %d has .latch directive with unrecognized entries (the total of %d entries).\n", |
| Io_MvGetLine(p->pMan, pToken), Vec_PtrSize(vTokens) ); |
| if ( Vec_PtrSize(vTokens) > 3 ) |
| Init = atoi( (char *)Vec_PtrEntryLast(vTokens) ); |
| else |
| Init = 2; |
| if ( Init < 0 || Init > 3 ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Initial state of the latch is incorrect \"%s\".", Io_MvGetLine(p->pMan, pToken), (char*)Vec_PtrEntry(vTokens,3) ); |
| return 0; |
| } |
| if ( Init == 0 ) |
| Abc_LatchSetInit0( pObj ); |
| else if ( Init == 1 ) |
| Abc_LatchSetInit1( pObj ); |
| else // if ( Init == 2 ) |
| Abc_LatchSetInitDc( pObj ); |
| } |
| } |
| else |
| { |
| // get the net corresponding to the output of the latch |
| pNet = Abc_NtkFindOrCreateNet( p->pNtk, (char *)Vec_PtrEntry(vTokens,2) ); |
| // get the net corresponding to the latch output (feeding into reset MUX) |
| pNet = Abc_NtkFindOrCreateNet( p->pNtk, Abc_ObjNameSuffix(pNet, "_out") ); |
| // create latch |
| pObj = Io_ReadCreateLatch( p->pNtk, (char *)Vec_PtrEntry(vTokens,1), Abc_ObjName(pNet) ); |
| // Abc_LatchSetInit0( pObj ); |
| Abc_LatchSetInit0( pObj ); |
| } |
| return 1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the latches line.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLineFlop( Io_MvMod_t * p, char * pLine ) |
| { |
| Vec_Ptr_t * vTokens = p->pMan->vTokens; |
| Abc_Obj_t * pObj; |
| char * pToken, * pOutput, * pInput; |
| int i, Init = 2; |
| assert( !p->pMan->fBlifMv ); |
| Io_MvSplitIntoTokens( vTokens, pLine, '\0' ); |
| pToken = (char *)Vec_PtrEntry(vTokens,0); |
| assert( !strcmp(pToken, "flop") ); |
| // get flop output |
| Vec_PtrForEachEntry( char *, vTokens, pToken, i ) |
| if ( pToken[0] == 'Q' && pToken[1] == '=' ) |
| break; |
| if ( i == Vec_PtrSize(vTokens) ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Cannot find flop output.", Io_MvGetLine(p->pMan, (char *)Vec_PtrEntry(vTokens,0)) ); |
| return 0; |
| } |
| pOutput = pToken+2; |
| // get flop input |
| Vec_PtrForEachEntry( char *, vTokens, pToken, i ) |
| if ( pToken[0] == 'D' && pToken[1] == '=' ) |
| break; |
| if ( i == Vec_PtrSize(vTokens) ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Cannot find flop input.", Io_MvGetLine(p->pMan, (char *)Vec_PtrEntry(vTokens,0)) ); |
| return 0; |
| } |
| pInput = pToken+2; |
| // create latch |
| pObj = Io_ReadCreateLatch( p->pNtk, pInput, pOutput ); |
| // get the init value |
| Vec_PtrForEachEntry( char *, vTokens, pToken, i ) |
| { |
| if ( !strncmp( pToken, "init=", 5 ) ) |
| { |
| Init = 0; |
| if ( pToken[5] == '1' ) |
| Init = 1; |
| else if ( pToken[5] == '2' ) |
| Init = 2; |
| else if ( pToken[5] != '0' ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Cannot read flop init value %s.", Io_MvGetLine(p->pMan, pToken), pToken ); |
| return 0; |
| } |
| break; |
| } |
| } |
| if ( Init < 0 || Init > 2 ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Initial state of the flop is incorrect \"%s\".", Io_MvGetLine(p->pMan, pToken), (char*)Vec_PtrEntry(vTokens,3) ); |
| return 0; |
| } |
| if ( Init == 0 ) |
| Abc_LatchSetInit0( pObj ); |
| else if ( Init == 1 ) |
| Abc_LatchSetInit1( pObj ); |
| else // if ( Init == 2 ) |
| Abc_LatchSetInitDc( pObj ); |
| return 1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the subckt line.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLineSubckt( Io_MvMod_t * p, char * pLine ) |
| { |
| Vec_Ptr_t * vTokens = p->pMan->vTokens; |
| Abc_Ntk_t * pModel; |
| Abc_Obj_t * pBox, * pNet, * pTerm; |
| char * pToken, * pName, * pName2, ** ppNames; |
| int nEquals, Last, i, k; |
| |
| // split the line into tokens |
| nEquals = Io_MvCountChars( pLine, '=' ); |
| Io_MvSplitIntoTokensAndClear( vTokens, pLine, '\0', '=' ); |
| pToken = (char *)Vec_PtrEntry(vTokens,0); |
| assert( !strcmp(pToken, "subckt") ); |
| //printf( "%d ", nEquals ); |
| |
| // get the model for this box |
| pName = (char *)Vec_PtrEntry(vTokens,1); |
| // skip instance name for now |
| for ( pToken = pName; *pToken; pToken++ ) |
| if ( *pToken == '|' ) |
| { |
| *pToken = 0; |
| break; |
| } |
| // find the model |
| pModel = Abc_DesFindModelByName( p->pMan->pDesign, pName ); |
| if ( pModel == NULL ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Cannot find the model for subcircuit %s.", Io_MvGetLine(p->pMan, pToken), pName ); |
| return 0; |
| } |
| /* |
| // check if the number of tokens is correct |
| if ( nEquals != Abc_NtkPiNum(pModel) + Abc_NtkPoNum(pModel) ) |
| { |
| sprintf( p->pMan->sError, "Line %d: The number of ports (%d) in .subckt differs from the sum of PIs and POs of the model (%d).", |
| Io_MvGetLine(p->pMan, pToken), nEquals, Abc_NtkPiNum(pModel) + Abc_NtkPoNum(pModel) ); |
| return 0; |
| } |
| */ |
| // get the names |
| ppNames = (char **)Vec_PtrArray(vTokens) + 2 + p->pMan->fBlifMv; |
| |
| // create the box with these terminals |
| if ( Abc_NtkHasBlackbox(pModel) ) |
| pBox = Abc_NtkCreateBlackbox( p->pNtk ); |
| else |
| pBox = Abc_NtkCreateWhitebox( p->pNtk ); |
| pBox->pData = pModel; |
| if ( p->pMan->fBlifMv ) |
| Abc_ObjAssignName( pBox, (char *)Vec_PtrEntry(vTokens,2), NULL ); |
| // go through formal inputs |
| Last = 0; |
| Abc_NtkForEachPi( pModel, pTerm, i ) |
| { |
| // find this terminal among the actual inputs of the subcircuit |
| pName2 = NULL; |
| pName = Abc_ObjName(Abc_ObjFanout0(pTerm)); |
| for ( k = 0; k < nEquals; k++ ) |
| if ( !strcmp( ppNames[2*((k+Last)%nEquals)], pName ) ) |
| { |
| pName2 = ppNames[2*((k+Last)%nEquals)+1]; |
| Last = k+Last+1; |
| break; |
| } |
| /* |
| if ( k == nEquals ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Cannot find PI \"%s\" of the model \"%s\" as a formal input of the subcircuit.", |
| Io_MvGetLine(p->pMan, pToken), pName, Abc_NtkName(pModel) ); |
| return 0; |
| } |
| */ |
| if ( pName2 == NULL ) |
| { |
| Abc_Obj_t * pNode = Abc_NtkCreateNode( p->pNtk ); |
| pNode->pData = Abc_SopRegister( (Mem_Flex_t *)p->pNtk->pManFunc, " 0\n" ); |
| pNet = Abc_NtkFindOrCreateNet( p->pNtk, Abc_ObjNameSuffix(pNode, "abc") ); |
| Abc_ObjAddFanin( pNet, pNode ); |
| pTerm = Abc_NtkCreateBi( p->pNtk ); |
| Abc_ObjAddFanin( pBox, pTerm ); |
| Abc_ObjAddFanin( pTerm, pNet ); |
| continue; |
| } |
| assert( pName2 != NULL ); |
| |
| // create the BI with the actual name |
| pNet = Abc_NtkFindOrCreateNet( p->pNtk, pName2 ); |
| pTerm = Abc_NtkCreateBi( p->pNtk ); |
| Abc_ObjAddFanin( pBox, pTerm ); |
| Abc_ObjAddFanin( pTerm, pNet ); |
| } |
| // go through formal outputs |
| Last = 0; |
| Abc_NtkForEachPo( pModel, pTerm, i ) |
| { |
| // find this terminal among the actual outputs of the subcircuit |
| pName2 = NULL; |
| pName = Abc_ObjName(Abc_ObjFanin0(pTerm)); |
| for ( k = 0; k < nEquals; k++ ) |
| if ( !strcmp( ppNames[2*((k+Last)%nEquals)], pName ) ) |
| { |
| pName2 = ppNames[2*((k+Last)%nEquals)+1]; |
| Last = k+Last+1; |
| break; |
| } |
| /* |
| if ( k == nEquals ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Cannot find PO \"%s\" of the modell \"%s\" as a formal output of the subcircuit.", |
| Io_MvGetLine(p->pMan, pToken), pName, Abc_NtkName(pModel) ); |
| return 0; |
| } |
| */ |
| |
| // create the BI with the actual name |
| pTerm = Abc_NtkCreateBo( p->pNtk ); |
| pNet = Abc_NtkFindOrCreateNet( p->pNtk, pName2 == NULL ? Abc_ObjNameSuffix(pTerm, "abc") : pName2 ); |
| Abc_ObjAddFanin( pNet, pTerm ); |
| Abc_ObjAddFanin( pTerm, pBox ); |
| } |
| return 1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the subckt line.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static Vec_Int_t * Io_MvParseLineOnehot( Io_MvMod_t * p, char * pLine ) |
| { |
| Vec_Ptr_t * vTokens = p->pMan->vTokens; |
| // Vec_Ptr_t * vResult; |
| Vec_Int_t * vResult; |
| Abc_Obj_t * pNet, * pTerm; |
| char * pToken; |
| int nEquals, i; |
| |
| // split the line into tokens |
| nEquals = Io_MvCountChars( pLine, '=' ); |
| Io_MvSplitIntoTokensAndClear( vTokens, pLine, '\0', '=' ); |
| pToken = (char *)Vec_PtrEntry(vTokens,0); |
| assert( !strcmp(pToken, "onehot") ); |
| |
| // iterate through the register names |
| // vResult = Vec_PtrAlloc( Vec_PtrSize(vTokens) ); |
| vResult = Vec_IntAlloc( Vec_PtrSize(vTokens) ); |
| Vec_PtrForEachEntryStart( char *, vTokens, pToken, i, 1 ) |
| { |
| // check if this register exists |
| pNet = Abc_NtkFindNet( p->pNtk, pToken ); |
| if ( pNet == NULL ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Signal with name \"%s\" does not exist in the model \"%s\".", |
| Io_MvGetLine(p->pMan, pToken), pToken, Abc_NtkName(p->pNtk) ); |
| return NULL; |
| } |
| // check if this is register output net |
| pTerm = Abc_ObjFanin0( pNet ); |
| if ( pTerm == NULL || Abc_ObjFanin0(pTerm) == NULL || !Abc_ObjIsLatch(Abc_ObjFanin0(pTerm)) ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Signal with name \"%s\" is not a register in the model \"%s\".", |
| Io_MvGetLine(p->pMan, pToken), pToken, Abc_NtkName(p->pNtk) ); |
| return NULL; |
| } |
| // save register name |
| // Vec_PtrPush( vResult, Abc_ObjName(pNet) ); |
| Vec_IntPush( vResult, (int)(ABC_PTRINT_T)Abc_ObjFanin0(pTerm)->pNext ); |
| // printf( "%d(%d) ", (int)Abc_ObjFanin0(pTerm)->pNext, ((int)Abc_ObjFanin0(pTerm)->pData) -1 ); |
| printf( "%d", ((int)(ABC_PTRINT_T)Abc_ObjFanin0(pTerm)->pData)-1 ); |
| } |
| printf( "\n" ); |
| return vResult; |
| } |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the mv line.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLineMv( Io_MvMod_t * p, char * pLine ) |
| { |
| Vec_Ptr_t * vTokens = p->pMan->vTokens; |
| Abc_Obj_t * pObj; |
| Io_MvVar_t * pVar = NULL; |
| Mem_Flex_t * pFlex; |
| char * pName; |
| int nCommas, nValues, i, k; |
| // count commas and get the tokens |
| nCommas = Io_MvCountChars( pLine, ',' ); |
| Io_MvSplitIntoTokensAndClear( vTokens, pLine, '\0', ',' ); |
| pName = (char *)Vec_PtrEntry(vTokens,0); |
| assert( !strcmp(pName, "mv") ); |
| // get the number of values |
| if ( Vec_PtrSize(vTokens) <= nCommas + 2 ) |
| { |
| sprintf( p->pMan->sError, "Line %d: The number of values in not specified in .mv line.", Io_MvGetLine(p->pMan, pName) ); |
| return 0; |
| } |
| nValues = atoi( (char *)Vec_PtrEntry(vTokens,nCommas+2) ); |
| if ( nValues < 2 || nValues > IO_BLIFMV_MAXVALUES ) |
| { |
| sprintf( p->pMan->sError, "Line %d: The number of values (%d) is incorrect (should be >= 2 and <= %d).", |
| Io_MvGetLine(p->pMan, pName), nValues, IO_BLIFMV_MAXVALUES ); |
| return 0; |
| } |
| // if there is no symbolic values, quit |
| if ( nValues == 2 && Vec_PtrSize(vTokens) == nCommas + 3 ) |
| return 1; |
| if ( Vec_PtrSize(vTokens) > nCommas + 3 && Vec_PtrSize(vTokens) - (nCommas + 3) != nValues ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Wrong number (%d) of symbolic value names (should be %d).", |
| Io_MvGetLine(p->pMan, pName), Vec_PtrSize(vTokens) - (nCommas + 3), nValues ); |
| return 0; |
| } |
| // go through variables |
| pFlex = (Mem_Flex_t *)Abc_NtkMvVarMan( p->pNtk ); |
| for ( i = 0; i <= nCommas; i++ ) |
| { |
| pName = (char *)Vec_PtrEntry( vTokens, i+1 ); |
| pObj = Abc_NtkFindOrCreateNet( p->pNtk, pName ); |
| // allocate variable |
| pVar = (Io_MvVar_t *)Mem_FlexEntryFetch( pFlex, sizeof(Io_MvVar_t) ); |
| pVar->nValues = nValues; |
| pVar->pNames = NULL; |
| // create names |
| if ( Vec_PtrSize(vTokens) > nCommas + 3 ) |
| { |
| pVar->pNames = (char **)Mem_FlexEntryFetch( pFlex, sizeof(char *) * nValues ); |
| Vec_PtrForEachEntryStart( char *, vTokens, pName, k, nCommas + 3 ) |
| { |
| pVar->pNames[k-(nCommas + 3)] = (char *)Mem_FlexEntryFetch( pFlex, strlen(pName) + 1 ); |
| strcpy( pVar->pNames[k-(nCommas + 3)], pName ); |
| } |
| } |
| // save the variable |
| Abc_ObjSetMvVar( pObj, pVar ); |
| } |
| // make sure the names are unique |
| assert(pVar); |
| if ( pVar->pNames ) |
| { |
| for ( i = 0; i < nValues; i++ ) |
| for ( k = i+1; k < nValues; k++ ) |
| if ( !strcmp(pVar->pNames[i], pVar->pNames[k]) ) |
| { |
| pName = (char *)Vec_PtrEntry(vTokens,0); |
| sprintf( p->pMan->sError, "Line %d: Symbolic value name \"%s\" is repeated in .mv line.", |
| Io_MvGetLine(p->pMan, pName), pVar->pNames[i] ); |
| return 0; |
| } |
| } |
| return 1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Writes the values into the BLIF-MV representation for the node.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvWriteValues( Abc_Obj_t * pNode, Vec_Str_t * vFunc ) |
| { |
| char Buffer[10]; |
| Abc_Obj_t * pFanin; |
| int i; |
| // add the fanin number of values |
| Abc_ObjForEachFanin( pNode, pFanin, i ) |
| { |
| sprintf( Buffer, "%d", Abc_ObjMvVarNum(pFanin) ); |
| Vec_StrPrintStr( vFunc, Buffer ); |
| Vec_StrPush( vFunc, ' ' ); |
| } |
| // add the node number of values |
| sprintf( Buffer, "%d", Abc_ObjMvVarNum(Abc_ObjFanout0(pNode)) ); |
| Vec_StrPrintStr( vFunc, Buffer ); |
| Vec_StrPush( vFunc, '\n' ); |
| return 1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Translated one literal.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLiteralMv( Io_MvMod_t * p, Abc_Obj_t * pNode, char * pToken, Vec_Str_t * vFunc, int iLit ) |
| { |
| char Buffer[10]; |
| Io_MvVar_t * pVar; |
| Abc_Obj_t * pFanin, * pNet; |
| char * pCur, * pNext; |
| int i; |
| // consider the equality literal |
| if ( pToken[0] == '=' ) |
| { |
| // find the fanins |
| Abc_ObjForEachFanin( pNode, pFanin, i ) |
| if ( !strcmp( Abc_ObjName(pFanin), pToken + 1 ) ) |
| break; |
| if ( i == Abc_ObjFaninNum(pNode) ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Node name in the table \"%s\" cannot be found on .names line.", |
| Io_MvGetLine(p->pMan, pToken), pToken + 1 ); |
| return 0; |
| } |
| Vec_StrPush( vFunc, '=' ); |
| sprintf( Buffer, "%d", i ); |
| Vec_StrPrintStr( vFunc, Buffer ); |
| Vec_StrPush( vFunc, (char)((iLit == -1)? '\n' : ' ') ); |
| return 1; |
| } |
| // consider regular literal |
| assert( iLit < Abc_ObjFaninNum(pNode) ); |
| pNet = iLit >= 0 ? Abc_ObjFanin(pNode, iLit) : Abc_ObjFanout0(pNode); |
| pVar = (Io_MvVar_t *)Abc_ObjMvVar( pNet ); |
| // if the var is absent or has no symbolic values quit |
| if ( pVar == NULL || pVar->pNames == NULL ) |
| { |
| Vec_StrPrintStr( vFunc, pToken ); |
| Vec_StrPush( vFunc, (char)((iLit == -1)? '\n' : ' ') ); |
| return 1; |
| } |
| // parse the literal using symbolic values |
| for ( pCur = pToken; *pCur; pCur++ ) |
| { |
| if ( Io_MvCharIsMvSymb(*pCur) ) |
| { |
| Vec_StrPush( vFunc, *pCur ); |
| continue; |
| } |
| // find the next MvSymb char |
| for ( pNext = pCur+1; *pNext; pNext++ ) |
| if ( Io_MvCharIsMvSymb(*pNext) ) |
| break; |
| // look for the value name |
| for ( i = 0; i < pVar->nValues; i++ ) |
| if ( !strncmp( pVar->pNames[i], pCur, pNext-pCur ) ) |
| break; |
| if ( i == pVar->nValues ) |
| { |
| *pNext = 0; |
| sprintf( p->pMan->sError, "Line %d: Cannot find value name \"%s\" among the value names of variable \"%s\".", |
| Io_MvGetLine(p->pMan, pToken), pCur, Abc_ObjName(pNet) ); |
| return 0; |
| } |
| // value name is found |
| sprintf( Buffer, "%d", i ); |
| Vec_StrPrintStr( vFunc, Buffer ); |
| // update the pointer |
| pCur = pNext - 1; |
| } |
| Vec_StrPush( vFunc, (char)((iLit == -1)? '\n' : ' ') ); |
| return 1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Constructs the MV-SOP cover from the file parsing info.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static char * Io_MvParseTableMv( Io_MvMod_t * p, Abc_Obj_t * pNode, Vec_Ptr_t * vTokens2, int nInputs, int nOutputs, int iOut ) |
| { |
| Vec_Str_t * vFunc = p->pMan->vFunc; |
| char * pFirst, * pToken; |
| int iStart, i; |
| // prepare the place for the cover |
| Vec_StrClear( vFunc ); |
| // write the number of values |
| // Io_MvWriteValues( pNode, vFunc ); |
| // get the first token |
| pFirst = (char *)Vec_PtrEntry( vTokens2, 0 ); |
| if ( pFirst[0] == '.' ) |
| { |
| // write the default literal |
| Vec_StrPush( vFunc, 'd' ); |
| pToken = (char *)Vec_PtrEntry(vTokens2, 1 + iOut); |
| if ( !Io_MvParseLiteralMv( p, pNode, pToken, vFunc, -1 ) ) |
| return NULL; |
| iStart = 1 + nOutputs; |
| } |
| else |
| iStart = 0; |
| // write the remaining literals |
| while ( iStart < Vec_PtrSize(vTokens2) ) |
| { |
| // input literals |
| for ( i = 0; i < nInputs; i++ ) |
| { |
| pToken = (char *)Vec_PtrEntry( vTokens2, iStart + i ); |
| if ( !Io_MvParseLiteralMv( p, pNode, pToken, vFunc, i ) ) |
| return NULL; |
| } |
| // output literal |
| pToken = (char *)Vec_PtrEntry( vTokens2, iStart + nInputs + iOut ); |
| if ( !Io_MvParseLiteralMv( p, pNode, pToken, vFunc, -1 ) ) |
| return NULL; |
| // update the counter |
| iStart += nInputs + nOutputs; |
| } |
| Vec_StrPush( vFunc, '\0' ); |
| return Vec_StrArray( vFunc ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Adds reset circuitry corresponding to latch with pName.] |
| |
| Description [Returns the reset node's net.] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static Abc_Obj_t * Io_MvParseAddResetCircuit( Io_MvMod_t * p, char * pName ) |
| { |
| char Buffer[50]; |
| Abc_Obj_t * pNode, * pData0Net, * pData1Net, * pResetLONet, * pOutNet; |
| Io_MvVar_t * pVar; |
| // make sure the reset latch exists |
| assert( p->pResetLatch != NULL ); |
| // get the reset net |
| pResetLONet = Abc_ObjFanout0(Abc_ObjFanout0(p->pResetLatch)); |
| // get the output net |
| pOutNet = Abc_NtkFindOrCreateNet( p->pNtk, pName ); |
| // get the data nets |
| pData0Net = Abc_NtkFindOrCreateNet( p->pNtk, Abc_ObjNameSuffix(pOutNet, "_reset") ); |
| pData1Net = Abc_NtkFindOrCreateNet( p->pNtk, Abc_ObjNameSuffix(pOutNet, "_out") ); |
| // duplicate MV variables |
| if ( Abc_NtkMvVar(p->pNtk) ) |
| { |
| pVar = (Io_MvVar_t *)Abc_ObjMvVar( pOutNet ); |
| Abc_ObjSetMvVar( pData0Net, Abc_NtkMvVarDup(p->pNtk, pVar) ); |
| Abc_ObjSetMvVar( pData1Net, Abc_NtkMvVarDup(p->pNtk, pVar) ); |
| } |
| // create the node |
| pNode = Abc_NtkCreateNode( p->pNtk ); |
| // create the output net |
| Abc_ObjAddFanin( pOutNet, pNode ); |
| // create the function |
| if ( p->pMan->fBlifMv ) |
| { |
| // Vec_Att_t * p = Abc_NtkMvVar( pNtk ); |
| // int nValues = Abc_ObjMvVarNum(pOutNet); |
| // sprintf( Buffer, "2 %d %d %d\n1 - - =1\n0 - - =2\n", nValues, nValues, nValues ); |
| sprintf( Buffer, "1 - - =1\n0 - - =2\n" ); |
| pNode->pData = Abc_SopRegister( (Mem_Flex_t *)p->pNtk->pManFunc, Buffer ); |
| } |
| else |
| pNode->pData = Abc_SopCreateMux( (Mem_Flex_t *)p->pNtk->pManFunc ); |
| // add nets |
| Abc_ObjAddFanin( pNode, pResetLONet ); |
| Abc_ObjAddFanin( pNode, pData1Net ); |
| Abc_ObjAddFanin( pNode, pData0Net ); |
| return pData0Net; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the nodes line.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLineNamesMvOne( Io_MvMod_t * p, Vec_Ptr_t * vTokens, Vec_Ptr_t * vTokens2, int nInputs, int nOutputs, int iOut, int fReset ) |
| { |
| Abc_Obj_t * pNet, * pNode; |
| char * pName; |
| // get the output name |
| pName = (char *)Vec_PtrEntry( vTokens, Vec_PtrSize(vTokens) - nOutputs + iOut ); |
| // create the node |
| if ( fReset ) |
| { |
| pNet = Abc_NtkFindNet( p->pNtk, pName ); |
| if ( pNet == NULL ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Latch with output signal \"%s\" does not exist.", Io_MvGetLine(p->pMan, pName), pName ); |
| return 0; |
| } |
| /* |
| if ( !Abc_ObjIsBo(Abc_ObjFanin0(pNet)) ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Reset line \"%s\" defines signal that is not a latch output.", Io_MvGetLine(p->pMan, pName), pName ); |
| return 0; |
| } |
| */ |
| // construct the reset circuit and get the reset net feeding into it |
| pNet = Io_MvParseAddResetCircuit( p, pName ); |
| // create fanins |
| pNode = Io_ReadCreateNode( p->pNtk, Abc_ObjName(pNet), (char **)(vTokens->pArray + 1), nInputs ); |
| assert( nInputs == Vec_PtrSize(vTokens) - 2 ); |
| } |
| else |
| { |
| pNet = Abc_NtkFindOrCreateNet( p->pNtk, pName ); |
| if ( Abc_ObjFaninNum(pNet) > 0 ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Signal \"%s\" is defined more than once.", Io_MvGetLine(p->pMan, pName), pName ); |
| return 0; |
| } |
| pNode = Io_ReadCreateNode( p->pNtk, pName, (char **)(vTokens->pArray + 1), nInputs ); |
| } |
| // create the cover |
| pNode->pData = Io_MvParseTableMv( p, pNode, vTokens2, nInputs, nOutputs, iOut ); |
| if ( pNode->pData == NULL ) |
| return 0; |
| pNode->pData = Abc_SopRegister( (Mem_Flex_t *)p->pNtk->pManFunc, (char *)pNode->pData ); |
| //printf( "Finished parsing node \"%s\" with table:\n%s\n", pName, pNode->pData ); |
| return 1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the nodes line.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLineNamesMv( Io_MvMod_t * p, char * pLine, int fReset ) |
| { |
| Vec_Ptr_t * vTokens = p->pMan->vTokens; |
| Vec_Ptr_t * vTokens2 = p->pMan->vTokens2; |
| Abc_Obj_t * pNet; |
| char * pName, * pFirst, * pArrow; |
| int nInputs, nOutputs, nLiterals, nLines, i; |
| assert( p->pMan->fBlifMv ); |
| // get the arrow if it is present |
| pArrow = Io_MvFindArrow( pLine ); |
| if ( !p->pMan->fBlifMv && pArrow ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Multi-output node symbol (->) in binary BLIF file.", Io_MvGetLine(p->pMan, pLine) ); |
| return 0; |
| } |
| // split names line into tokens |
| Io_MvSplitIntoTokens( vTokens, pLine, '\0' ); |
| if ( fReset ) |
| assert( !strcmp((char *)Vec_PtrEntry(vTokens,0), "r") || !strcmp((char *)Vec_PtrEntry(vTokens,0), "reset") ); |
| else |
| assert( !strcmp((char *)Vec_PtrEntry(vTokens,0), "names") || !strcmp((char *)Vec_PtrEntry(vTokens,0), "table") ); |
| // find the number of inputs and outputs |
| nInputs = Vec_PtrSize(vTokens) - 2; |
| nOutputs = 1; |
| if ( pArrow != NULL ) |
| { |
| for ( i = Vec_PtrSize(vTokens) - 2; i >= 1; i-- ) |
| if ( pArrow < (char*)Vec_PtrEntry(vTokens,i) ) |
| { |
| nInputs--; |
| nOutputs++; |
| } |
| } |
| // split table into tokens |
| pName = (char *)Vec_PtrEntryLast( vTokens ); |
| Io_MvSplitIntoTokensMv( vTokens2, pName + strlen(pName) ); |
| pFirst = (char *)Vec_PtrEntry( vTokens2, 0 ); |
| if ( pFirst[0] == '.' ) |
| { |
| assert( pFirst[1] == 'd' ); |
| nLiterals = Vec_PtrSize(vTokens2) - 1 - nOutputs; |
| } |
| else |
| nLiterals = Vec_PtrSize(vTokens2); |
| // check the number of lines |
| if ( nLiterals % (nInputs + nOutputs) != 0 ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Wrong number of literals in the table of node \"%s\". (Spaces inside literals are not allowed.)", Io_MvGetLine(p->pMan, pFirst), pName ); |
| return 0; |
| } |
| // check for the ND table |
| nLines = nLiterals / (nInputs + nOutputs); |
| if ( nInputs == 0 && nLines > 1 ) |
| { |
| // add the outputs to the PIs |
| for ( i = 0; i < nOutputs; i++ ) |
| { |
| pName = (char *)Vec_PtrEntry( vTokens, Vec_PtrSize(vTokens) - nOutputs + i ); |
| // get the net corresponding to this node |
| pNet = Abc_NtkFindOrCreateNet(p->pNtk, pName); |
| if ( fReset ) |
| { |
| assert( p->pResetLatch != NULL ); |
| // construct the reset circuit and get the reset net feeding into it |
| pNet = Io_MvParseAddResetCircuit( p, pName ); |
| } |
| // add the new PI node |
| // Abc_ObjAddFanin( pNet, Abc_NtkCreatePi(p->pNtk) ); |
| // fprintf( stdout, "Io_ReadBlifMv(): Adding PI for internal non-deterministic node \"%s\".\n", pName ); |
| p->pMan->nNDnodes++; |
| Abc_ObjAddFanin( pNet, Abc_NtkCreateNodeConst0(p->pNtk) ); |
| } |
| return 1; |
| } |
| // iterate through the outputs |
| for ( i = 0; i < nOutputs; i++ ) |
| { |
| if ( !Io_MvParseLineNamesMvOne( p, vTokens, vTokens2, nInputs, nOutputs, i, fReset ) ) |
| return 0; |
| } |
| return 1; |
| } |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [Constructs the SOP cover from the file parsing info.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static char * Io_MvParseTableBlif( Io_MvMod_t * p, char * pTable, int nFanins ) |
| { |
| Vec_Ptr_t * vTokens = p->pMan->vTokens; |
| Vec_Str_t * vFunc = p->pMan->vFunc; |
| char * pProduct, * pOutput, c; |
| int i, Polarity = -1; |
| |
| p->pMan->nTablesRead++; |
| // get the tokens |
| Io_MvSplitIntoTokens( vTokens, pTable, '.' ); |
| if ( Vec_PtrSize(vTokens) == 0 ) |
| return Abc_SopCreateConst0( (Mem_Flex_t *)p->pNtk->pManFunc ); |
| if ( Vec_PtrSize(vTokens) == 1 ) |
| { |
| pOutput = (char *)Vec_PtrEntry( vTokens, 0 ); |
| c = pOutput[0]; |
| if ( (c!='0'&&c!='1'&&c!='x'&&c!='n') || pOutput[1] ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Constant table has wrong output value \"%s\".", Io_MvGetLine(p->pMan, pOutput), pOutput ); |
| return NULL; |
| } |
| return pOutput[0] == '0' ? Abc_SopCreateConst0((Mem_Flex_t *)p->pNtk->pManFunc) : Abc_SopCreateConst1((Mem_Flex_t *)p->pNtk->pManFunc); |
| } |
| pProduct = (char *)Vec_PtrEntry( vTokens, 0 ); |
| if ( Vec_PtrSize(vTokens) % 2 == 1 ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Table has odd number of tokens (%d).", Io_MvGetLine(p->pMan, pProduct), Vec_PtrSize(vTokens) ); |
| return NULL; |
| } |
| // parse the table |
| Vec_StrClear( vFunc ); |
| for ( i = 0; i < Vec_PtrSize(vTokens)/2; i++ ) |
| { |
| pProduct = (char *)Vec_PtrEntry( vTokens, 2*i + 0 ); |
| pOutput = (char *)Vec_PtrEntry( vTokens, 2*i + 1 ); |
| if ( strlen(pProduct) != (unsigned)nFanins ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Cube \"%s\" has size different from the fanin count (%d).", Io_MvGetLine(p->pMan, pProduct), pProduct, nFanins ); |
| return NULL; |
| } |
| c = pOutput[0]; |
| if ( (c!='0'&&c!='1'&&c!='x'&&c!='n') || pOutput[1] ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Output value \"%s\" is incorrect.", Io_MvGetLine(p->pMan, pProduct), pOutput ); |
| return NULL; |
| } |
| if ( Polarity == -1 ) |
| Polarity = (c=='1' || c=='x'); |
| else if ( Polarity != (c=='1' || c=='x') ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Output value \"%s\" differs from the value in the first line of the table (%d).", Io_MvGetLine(p->pMan, pProduct), pOutput, Polarity ); |
| return NULL; |
| } |
| // parse one product |
| Vec_StrPrintStr( vFunc, pProduct ); |
| Vec_StrPush( vFunc, ' ' ); |
| Vec_StrPush( vFunc, pOutput[0] ); |
| Vec_StrPush( vFunc, '\n' ); |
| } |
| Vec_StrPush( vFunc, '\0' ); |
| return Vec_StrArray( vFunc ); |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the nodes line.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLineNamesBlif( Io_MvMod_t * p, char * pLine ) |
| { |
| Vec_Ptr_t * vTokens = p->pMan->vTokens; |
| Abc_Obj_t * pNet, * pNode; |
| char * pName; |
| assert( !p->pMan->fBlifMv ); |
| Io_MvSplitIntoTokens( vTokens, pLine, '\0' ); |
| // parse the mapped node |
| if ( !strcmp((char *)Vec_PtrEntry(vTokens,0), "gate") ) |
| return Io_MvParseLineGateBlif( p, vTokens ); |
| // parse the regular name line |
| assert( !strcmp((char *)Vec_PtrEntry(vTokens,0), "names") ); |
| pName = (char *)Vec_PtrEntryLast( vTokens ); |
| pNet = Abc_NtkFindOrCreateNet( p->pNtk, pName ); |
| if ( Abc_ObjFaninNum(pNet) > 0 ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Signal \"%s\" is defined more than once.", Io_MvGetLine(p->pMan, pName), pName ); |
| return 0; |
| } |
| // create fanins |
| pNode = Io_ReadCreateNode( p->pNtk, pName, (char **)(vTokens->pArray + 1), Vec_PtrSize(vTokens) - 2 ); |
| // parse the table of this node |
| pNode->pData = Io_MvParseTableBlif( p, pName + strlen(pName), Abc_ObjFaninNum(pNode) ); |
| if ( pNode->pData == NULL ) |
| return 0; |
| pNode->pData = Abc_SopRegister( (Mem_Flex_t *)p->pNtk->pManFunc, (char *)pNode->pData ); |
| return 1; |
| } |
| |
| ABC_NAMESPACE_IMPL_END |
| |
| #include "map/mio/mio.h" |
| #include "base/main/main.h" |
| |
| ABC_NAMESPACE_IMPL_START |
| |
| |
| /**Function************************************************************* |
| |
| Synopsis [Parses the nodes line.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLineShortBlif( Io_MvMod_t * p, char * pLine ) |
| { |
| Vec_Ptr_t * vTokens = p->pMan->vTokens; |
| Abc_Obj_t * pNet, * pNode; |
| char * pName; |
| assert( !p->pMan->fBlifMv ); |
| Io_MvSplitIntoTokens( vTokens, pLine, '\0' ); |
| if ( Vec_PtrSize(vTokens) != 3 ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Expecting three entries in the .short line.", Io_MvGetLine(p->pMan, (char *)Vec_PtrEntry(vTokens,0)) ); |
| return 0; |
| } |
| // parse the regular name line |
| assert( !strcmp((char *)Vec_PtrEntry(vTokens,0), "short") ); |
| pName = (char *)Vec_PtrEntryLast( vTokens ); |
| pNet = Abc_NtkFindOrCreateNet( p->pNtk, pName ); |
| if ( Abc_ObjFaninNum(pNet) > 0 ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Signal \"%s\" is defined more than once.", Io_MvGetLine(p->pMan, pName), pName ); |
| return 0; |
| } |
| // create fanins |
| pNode = Io_ReadCreateNode( p->pNtk, pName, (char **)(vTokens->pArray + 1), 1 ); |
| // parse the table of this node |
| if ( p->pNtk->ntkFunc == ABC_FUNC_MAP ) |
| { |
| Mio_Library_t * pGenlib; |
| Mio_Gate_t * pGate; |
| // check that the library is available |
| pGenlib = (Mio_Library_t *)Abc_FrameReadLibGen(); |
| if ( pGenlib == NULL ) |
| { |
| sprintf( p->pMan->sError, "Line %d: The current library is not available.", Io_MvGetLine(p->pMan, pName) ); |
| return 0; |
| } |
| // get the gate |
| pGate = Mio_LibraryReadBuf( pGenlib ); |
| if ( pGate == NULL ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Cannot find buffer gate in the library.", Io_MvGetLine(p->pMan, pName) ); |
| return 0; |
| } |
| Abc_ObjSetData( pNode, pGate ); |
| } |
| else |
| pNode->pData = Abc_SopRegister( (Mem_Flex_t *)p->pNtk->pManFunc, "1 1\n" ); |
| return 1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Duplicate the MV variable.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| Io_MvVar_t * Abc_NtkMvVarDup( Abc_Ntk_t * pNtk, Io_MvVar_t * pVar ) |
| { |
| Mem_Flex_t * pFlex; |
| Io_MvVar_t * pVarDup; |
| int i; |
| if ( pVar == NULL ) |
| return NULL; |
| pFlex = (Mem_Flex_t *)Abc_NtkMvVarMan( pNtk ); |
| assert( pFlex != NULL ); |
| pVarDup = (Io_MvVar_t *)Mem_FlexEntryFetch( pFlex, sizeof(Io_MvVar_t) ); |
| pVarDup->nValues = pVar->nValues; |
| pVarDup->pNames = NULL; |
| if ( pVar->pNames == NULL ) |
| return pVarDup; |
| pVarDup->pNames = (char **)Mem_FlexEntryFetch( pFlex, sizeof(char *) * pVar->nValues ); |
| for ( i = 0; i < pVar->nValues; i++ ) |
| { |
| pVarDup->pNames[i] = (char *)Mem_FlexEntryFetch( pFlex, strlen(pVar->pNames[i]) + 1 ); |
| strcpy( pVarDup->pNames[i], pVar->pNames[i] ); |
| } |
| return pVarDup; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static char * Io_ReadBlifCleanName( char * pName ) |
| { |
| int i, Length; |
| Length = strlen(pName); |
| for ( i = 0; i < Length; i++ ) |
| if ( pName[i] == '=' ) |
| return pName + i + 1; |
| return NULL; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static int Io_MvParseLineGateBlif( Io_MvMod_t * p, Vec_Ptr_t * vTokens ) |
| { |
| extern int Io_ReadBlifReorderFormalNames( Vec_Ptr_t * vTokens, Mio_Gate_t * pGate, Mio_Gate_t * pTwin ); |
| Mio_Library_t * pGenlib; |
| Mio_Gate_t * pGate; |
| Abc_Obj_t * pNode; |
| char ** ppNames, * pName; |
| int i, nNames; |
| |
| pName = (char *)vTokens->pArray[0]; |
| |
| // check that the library is available |
| pGenlib = (Mio_Library_t *)Abc_FrameReadLibGen(); |
| if ( pGenlib == NULL ) |
| { |
| sprintf( p->pMan->sError, "Line %d: The current library is not available.", Io_MvGetLine(p->pMan, pName) ); |
| return 0; |
| } |
| |
| // create a new node and add it to the network |
| if ( vTokens->nSize < 2 ) |
| { |
| sprintf( p->pMan->sError, "Line %d: The .gate line has less than two tokens.", Io_MvGetLine(p->pMan, pName) ); |
| return 0; |
| } |
| |
| // get the gate |
| pGate = Mio_LibraryReadGateByName( pGenlib, (char *)vTokens->pArray[1], NULL ); |
| if ( pGate == NULL ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Cannot find gate \"%s\" in the library.", Io_MvGetLine(p->pMan, pName), (char*)vTokens->pArray[1] ); |
| return 0; |
| } |
| |
| // if this is the first line with gate, update the network type |
| if ( Abc_NtkNodeNum(p->pNtk) == 0 ) |
| { |
| assert( p->pNtk->ntkFunc == ABC_FUNC_SOP ); |
| p->pNtk->ntkFunc = ABC_FUNC_MAP; |
| Mem_FlexStop( (Mem_Flex_t *)p->pNtk->pManFunc, 0 ); |
| p->pNtk->pManFunc = pGenlib; |
| } |
| |
| // reorder the formal inputs to be in the same order as in the gate |
| if ( !Io_ReadBlifReorderFormalNames( vTokens, pGate, Mio_GateReadTwin(pGate) ) ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Mismatch in the fanins of gate \"%s\".", Io_MvGetLine(p->pMan, pName), (char*)vTokens->pArray[1] ); |
| return 0; |
| } |
| |
| // remove the formal parameter names |
| for ( i = 2; i < vTokens->nSize; i++ ) |
| { |
| if ( vTokens->pArray[i] == NULL ) |
| continue; |
| vTokens->pArray[i] = Io_ReadBlifCleanName( (char *)vTokens->pArray[i] ); |
| if ( vTokens->pArray[i] == NULL ) |
| { |
| sprintf( p->pMan->sError, "Line %d: Invalid gate input assignment.", Io_MvGetLine(p->pMan, pName) ); |
| return 0; |
| } |
| } |
| |
| // create the node |
| if ( Mio_GateReadTwin(pGate) == NULL ) |
| { |
| nNames = vTokens->nSize - 3; |
| ppNames = (char **)vTokens->pArray + 2; |
| pNode = Io_ReadCreateNode( p->pNtk, ppNames[nNames], ppNames, nNames ); |
| Abc_ObjSetData( pNode, pGate ); |
| } |
| else |
| { |
| nNames = vTokens->nSize - 4; |
| ppNames = (char **)vTokens->pArray + 2; |
| assert( ppNames[nNames] != NULL || ppNames[nNames+1] != NULL ); |
| if ( ppNames[nNames] ) |
| { |
| pNode = Io_ReadCreateNode( p->pNtk, ppNames[nNames], ppNames, nNames ); |
| Abc_ObjSetData( pNode, pGate ); |
| } |
| if ( ppNames[nNames+1] ) |
| { |
| pNode = Io_ReadCreateNode( p->pNtk, ppNames[nNames+1], ppNames, nNames ); |
| Abc_ObjSetData( pNode, Mio_GateReadTwin(pGate) ); |
| } |
| } |
| |
| return 1; |
| } |
| |
| /**Function************************************************************* |
| |
| Synopsis [Box mapping procedures.] |
| |
| Description [] |
| |
| SideEffects [] |
| |
| SeeAlso [] |
| |
| ***********************************************************************/ |
| static inline void Abc_MapBoxSetPrevNext( Vec_Ptr_t * vDrivers, Vec_Int_t * vMapIn, Vec_Int_t * vMapOut, int Id ) |
| { |
| Abc_Obj_t * pNode; |
| pNode = (Abc_Obj_t *)Vec_PtrEntry(vDrivers, Id+2); |
| Vec_IntWriteEntry( vMapIn, Abc_ObjId(Abc_ObjFanin0(Abc_ObjFanin0(pNode))), Id ); |
| pNode = (Abc_Obj_t *)Vec_PtrEntry(vDrivers, Id+4); |
| Vec_IntWriteEntry( vMapOut, Abc_ObjId(Abc_ObjFanin0(Abc_ObjFanin0(pNode))), Id ); |
| } |
| static inline int Abc_MapBox2Next( Vec_Ptr_t * vDrivers, Vec_Int_t * vMapIn, Vec_Int_t * vMapOut, int Id ) |
| { |
| Abc_Obj_t * pNode = (Abc_Obj_t *)Vec_PtrEntry(vDrivers, Id+4); |
| return Vec_IntEntry( vMapIn, Abc_ObjId(Abc_ObjFanin0(Abc_ObjFanin0(pNode))) ); |
| } |
| static inline int Abc_MapBox2Prev( Vec_Ptr_t * vDrivers, Vec_Int_t * vMapIn, Vec_Int_t * vMapOut, int Id ) |
| { |
| Abc_Obj_t * pNode = (Abc_Obj_t *)Vec_PtrEntry(vDrivers, Id+2); |
| return Vec_IntEntry( vMapOut, Abc_ObjId(Abc_ObjFanin0(Abc_ObjFanin0(pNode))) ); |
| } |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// END OF FILE /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| |
| ABC_NAMESPACE_IMPL_END |
| |
