luke
/
abc
mirror of https://github.com/YosysHQ/abc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
abc/src/base/io/ioReadBlifMv.c

2412 lines
78 KiB
C
Raw Blame History

/**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 "abc.h"
#include "extra.h"
#include "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_Lib_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_Lib_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 == '!'; }
static Vec_Vec_t * Io_MvExtractBoxInfo( Abc_Ntk_t * pNtk );
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;
Abc_Lib_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_LibCreate( 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 );
vGlobalLtlArray = Vec_PtrAlloc( 100 );
// 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_LibFree( pDesign, NULL );
return NULL;
}
}
}
//Abc_LibPrint( pDesign );
// detect top-level model
RetValue = Abc_LibFindTopLevelModels( 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_LibFree( 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 );
Vec_PtrForEachEntry( char *, vGlobalLtlArray, pLtlProp, i )
Vec_PtrPush( pNtk->vLtlProperties, pLtlProp );
Vec_PtrFreeP( &vGlobalLtlArray );
pNtk->vRealPos = Io_MvExtractBoxInfo( pNtk );
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_LibFree( 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 []
***********************************************************************/
static char * Io_MvLoadFile( char * pFileName )
{
FILE * pFile;
int nFileSize;
char * pContents;
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 );
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: Skipping EXDC network.\n", Io_MvGetLine(p, pCur) );
// break;
if ( p->pLatest )
Vec_PtrPush( p->vModels, p->pLatest );
p->pLatest = NULL;
}
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_LibAddModel( 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
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_Lib_t * Io_MvParse( Io_MvMan_t * p )
{
Abc_Lib_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
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;
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;
p->pNtk->nRealPos = Abc_NtkPoNum(p->pNtk);
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_LibFindModelByName( 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 ( k == nEquals )
{
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;
}
*/
assert( pName2 != NULL );
// create the BI with the actual name
pTerm = Abc_NtkCreateBo( p->pNtk );
pNet = Abc_NtkFindOrCreateNet( p->pNtk, k == nEquals ? 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;
}
/**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
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;
}
ABC_NAMESPACE_IMPL_END
#include "mio.h"
#include "main.h"
ABC_NAMESPACE_IMPL_START
/**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_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] );
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 ) )
{
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++ )
{
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
ppNames = (char **)vTokens->pArray + 2;
nNames = vTokens->nSize - 3;
pNode = Io_ReadCreateNode( p->pNtk, ppNames[nNames], ppNames, nNames );
// set the pointer to the functionality of the node
Abc_ObjSetData( pNode, 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))) );
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static Vec_Vec_t * Io_MvExtractBoxInfo_( Abc_Ntk_t * pNtk )
{
Vec_Int_t * vMapIn, * vMapOut, * vList;
Vec_Ptr_t * vBoxInfo, * vDrivers;
Abc_Obj_t * pObj;
int i, boxId;
// quit if there is no boxes
if ( pNtk->nRealPos == 0 || (Abc_NtkPoNum(pNtk) - pNtk->nRealPos) % 5 != 0 )
return NULL;
// allocate
vBoxInfo = Vec_PtrAlloc( 10 );
vDrivers = Vec_PtrAlloc( Abc_NtkPoNum(pNtk) );
vMapIn = Vec_IntStartFull( Abc_NtkObjNumMax(pNtk) );
vMapOut = Vec_IntStartFull( Abc_NtkObjNumMax(pNtk) );
// collect drivers
Abc_NtkForEachPo( pNtk, pObj, i )
Vec_PtrPush( vDrivers, Abc_ObjFanin0(Abc_ObjFanin0(pObj)) );
// map box signals into box numbers
for ( i = pNtk->nRealPos; i < Abc_NtkPoNum(pNtk); i += 5 )
{
// int k;
// for ( k = 0; k < 5; k++ )
// printf( "%d ", Abc_ObjFanin0(Abc_ObjFanin0(Abc_ObjFanin0(Abc_NtkPo(pNtk,i+k))))->Id );
// printf( "\n" );
Abc_MapBoxSetPrevNext( vDrivers, vMapIn, vMapOut, i );
}
// find those that do not have input mapped
for ( i = pNtk->nRealPos; i < Abc_NtkPoNum(pNtk); i += 5 )
{
if ( Abc_MapBox2Prev( vDrivers, vMapIn, vMapOut, i ) != ~0 )
continue;
// create new list
vList = Vec_IntAlloc( 32 );
boxId = i;
while ( boxId != ~0 )
{
Vec_IntPush( vList, boxId );
boxId = Abc_MapBox2Next( vDrivers, vMapIn, vMapOut, boxId );
}
Vec_PtrPush( vBoxInfo, vList );
//printf( " %d", Vec_IntSize(vList) );
}
//printf( "\n" );
if ( 5 * Vec_VecSizeSize((Vec_Vec_t *)vBoxInfo) != (Abc_NtkPoNum(pNtk) - pNtk->nRealPos) )
printf( "Mismatch in the number of boxes!!!\n" );
// clean up
Vec_IntFree( vMapIn );
Vec_IntFree( vMapOut );
Vec_PtrFree( vDrivers );
return (Vec_Vec_t *)vBoxInfo;
}
/**Function*************************************************************
Synopsis [Compares strings up to the first underscore.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Io_MvExtractCompareStr( char * pName1, char * pName2 )
{
while ( *pName1 && *pName1 != '_' && (*pName1 == *pName2) )
pName1++, pName2++;
return *pName1 - *pName2;
}
/**Function*************************************************************
Synopsis [Returns the first number of the string.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Io_MvExtractReadNum1( char * pName )
{
while ( *pName && (*pName < '0' || *pName > '9') )
pName++;
if ( *pName == 0 )
return -1;
return atoi( pName );
}
/**Function*************************************************************
Synopsis [Returns the second number of the string.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Io_MvExtractReadNum2( char * pName )
{
int Counter = 0;
while ( *pName )
{
Counter += (*pName++ == '_');
if ( Counter == 2 )
break;
}
if ( *pName == 0 )
return -1;
return atoi( pName );
}
/**Function*************************************************************
Synopsis [Procedure used for sorting the nodes in decreasing order of levels.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Io_MvExtractCompareNames( Abc_Obj_t ** pp1, Abc_Obj_t ** pp2 )
{
char * pName1 = (char *)(*pp1)->pCopy;
char * pName2 = (char *)(*pp2)->pCopy;
// int Diff = Io_MvExtractReadNum1(pName1) - Io_MvExtractReadNum1(pName2);
int Diff = Io_MvExtractCompareStr( pName1, pName2 );
if ( Diff < 0 )
return -1;
if ( Diff > 0 )
return 1;
Diff = Io_MvExtractReadNum2(pName1) - Io_MvExtractReadNum2(pName2);
if ( Diff < 0 )
return -1;
if ( Diff > 0 )
return 1;
return 0;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static Vec_Vec_t * Io_MvExtractBoxInfo( Abc_Ntk_t * pNtk )
{
int fVerbose = 0;
Vec_Vec_t * vBoxInfo = NULL;
Vec_Ptr_t * vPetals;
Abc_Obj_t * pObj;
char * pPrev, * pThis;
int i, Level;
// quit if there is no boxes
if ( pNtk->nRealPos == 0 || (Abc_NtkPoNum(pNtk) - pNtk->nRealPos) % 5 != 0 )
return NULL;
// transfer names
Abc_NtkForEachPo( pNtk, pObj, i )
{
pObj->pCopy = (Abc_Obj_t *)Abc_ObjName( Abc_ObjFanin0(pObj) );
pObj->iData = i;
}
// collect POs
vPetals = Vec_PtrAlloc( Abc_NtkPoNum(pNtk) );
for ( i = pNtk->nRealPos; i < Abc_NtkPoNum(pNtk); i += 5 )
Vec_PtrPush( vPetals, Abc_NtkPo(pNtk, i) );
// sort by name
qsort( (void *)Vec_PtrArray(vPetals), Vec_PtrSize(vPetals), sizeof(Abc_Obj_t *),
(int (*)(const void *, const void *)) Io_MvExtractCompareNames );
// sort the POs
Level = -1;
pPrev = "dummy";
vBoxInfo = Vec_VecAlloc( 32 );
Vec_PtrForEachEntry( Abc_Obj_t *, vPetals, pObj, i )
{
pThis = (char *)pObj->pCopy;
if ( Io_MvExtractCompareStr( pPrev, pThis ) )
{
Level++;
if ( fVerbose )
printf( "\n" );
}
Vec_VecPushInt( vBoxInfo, Level, pObj->iData );
if ( fVerbose )
printf( "%s ", (char *)pObj->pCopy );
pPrev = pThis;
}
if ( fVerbose )
printf( "\n" );
if ( 5 * Vec_VecSizeSize(vBoxInfo) != (Abc_NtkPoNum(pNtk) - pNtk->nRealPos) )
printf( "Mismatch in the number of boxes!!!\n" );
// clean up
Vec_PtrFree( vPetals );
// remove names
Abc_NtkForEachPo( pNtk, pObj, i )
{
pObj->pCopy = NULL;
pObj->iData = 0;
}
return vBoxInfo;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_IMPL_END
Reference in New Issue View Git Blame Copy Permalink