#include "base/abc/abc.h"
#include "misc/vec/vecPtr.h"

Data Structures
struct	Io_BlifObj_t_

struct	Io_BlifMan_t_

Typedefs
typedef struct Io_BlifObj_t_	Io_BlifObj_t

typedef struct Io_BlifMan_t_	Io_BlifMan_t

Enumerations
enum	Io_BlifInit_t { IO_BLIF_INIT_NONE = 0, IO_BLIF_INIT_ZERO, IO_BLIF_INIT_ONE, IO_BLIF_INIT_DC }
	DECLARATIONS ///. More...

Functions
static Io_BlifMan_t *	Io_BlifAlloc ()

static void	Io_BlifFree (Io_BlifMan_t *p)

static char *	Io_BlifLoadFile (char *pFileName)

static void	Io_BlifReadPreparse (Io_BlifMan_t *p)

static Abc_Ntk_t *	Io_BlifParse (Io_BlifMan_t *p)

static int	Io_BlifParseModel (Io_BlifMan_t p, char pLine)

static int	Io_BlifParseInputs (Io_BlifMan_t p, char pLine)

static int	Io_BlifParseOutputs (Io_BlifMan_t p, char pLine)

static int	Io_BlifParseLatch (Io_BlifMan_t p, char pLine)

static int	Io_BlifParseNames (Io_BlifMan_t p, char pLine)

static int	Io_BlifParseConstruct (Io_BlifMan_t *p)

static int	Io_BlifCharIsSpace (char s)

Abc_Ntk_t *	Io_ReadBlifAsAig (char *pFileName, int fCheck)
	FUNCTION DEFINITIONS ///. More...

static unsigned	Io_BlifHashString (char *pName, int TableSize)

static Io_BlifObj_t **	Io_BlifHashLookup (Io_BlifMan_t p, char pName)

static Io_BlifObj_t *	Io_BlifHashFindOrAdd (Io_BlifMan_t p, char pName)

static void	Io_BlifCollectTokens (Vec_Ptr_t vTokens, char pInput, char *pOutput)

static void	Io_BlifSplitIntoTokens (Vec_Ptr_t vTokens, char pLine, char Stop)

static int	Io_BlifGetLine (Io_BlifMan_t p, char pToken)

static int	Io_BlifEstimatePiNum (Io_BlifMan_t *p)

static int	Io_BlifEstimateAndNum (Io_BlifMan_t *p)

static Abc_Obj_t *	Io_BlifParseTable (Io_BlifMan_t p, char pTable, Vec_Ptr_t *vFanins)

static Abc_Obj_t *	Io_BlifParseConstruct_rec (Io_BlifMan_t p, char pName)

Typedef Documentation

typedef struct Io_BlifMan_t_ Io_BlifMan_t

Definition at line 55 of file ioReadBlifAig.c.

typedef struct Io_BlifObj_t_ Io_BlifObj_t

Definition at line 39 of file ioReadBlifAig.c.

Enumeration Type Documentation

enum Io_BlifInit_t

DECLARATIONS ///.

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

FileName [ioReadBlifAig.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Command processing package.]

Synopsis [Procedures to read BLIF file into AIG.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - December 23, 2006.]

Revision [

Id:: ioReadBlifAig.c,v 1.00 2006/12/23 00:00:00 alanmi Exp

]

Enumerator
IO_BLIF_INIT_NONE
IO_BLIF_INIT_ZERO
IO_BLIF_INIT_ONE
IO_BLIF_INIT_DC

Definition at line 32 of file ioReadBlifAig.c.

              { 
     IO_BLIF_INIT_NONE = 0,  // 0:  unknown
     IO_BLIF_INIT_ZERO,      // 1:  zero
     IO_BLIF_INIT_ONE,       // 2:  one
     IO_BLIF_INIT_DC         // 3:  don't-care
 } Io_BlifInit_t;

Function Documentation

static Io_BlifMan_t * Io_BlifAlloc ( )

static

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

Synopsis [Allocates the BLIF parsing structure.]

Description []

SideEffects []

SeeAlso []

Definition at line 173 of file ioReadBlifAig.c.

 {
     Io_BlifMan_t * p;
     p = ABC_ALLOC( Io_BlifMan_t, 1 );
     memset( p, 0, sizeof(Io_BlifMan_t) );
     p->vLines   = Vec_PtrAlloc( 512 );
     p->vInputs  = Vec_PtrAlloc( 512 );
     p->vOutputs = Vec_PtrAlloc( 512 );
     p->vLatches = Vec_PtrAlloc( 512 );
     p->vNames   = Vec_PtrAlloc( 512 );
     p->vTokens  = Vec_PtrAlloc( 512 );
     p->vPis     = Vec_PtrAlloc( 512 );
     p->vPos     = Vec_PtrAlloc( 512 );
     p->vLis     = Vec_PtrAlloc( 512 );
     p->vLos     = Vec_PtrAlloc( 512 );
     return p;
 }

static int Io_BlifCharIsSpace ( char s )

static

Definition at line 101 of file ioReadBlifAig.c.

101 { return s == ' ' || s == '\t' || s == '\r' || s == '\n'; }

static void Io_BlifCollectTokens	(	Vec_Ptr_t *	vTokens,
		char *	pInput,
		char *	pOutput
	)

static

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

Synopsis [Collects the already split tokens.]

Description []

SideEffects []

SeeAlso []

Definition at line 302 of file ioReadBlifAig.c.

 {
     char * pCur;
     Vec_PtrClear( vTokens );
     for ( pCur = pInput; pCur < pOutput; pCur++ )
     {
         if ( *pCur == 0 )
             continue;
         Vec_PtrPush( vTokens, pCur );
         while ( *++pCur );
     }
 }

static int Io_BlifEstimateAndNum ( Io_BlifMan_t * p )

static

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

Synopsis [Conservatively estimates the number of AIG nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 400 of file ioReadBlifAig.c.

 {
     Io_BlifObj_t * pObj;
     char * pCur;
     int i, CounterOne, Counter = 0;
     for ( i = 0; i < p->iObjNext; i++ )
     {
         pObj = p->pObjects + i;
         if ( !pObj->fDef )
             continue;
         CounterOne = 0;
         for ( pCur = pObj->pName + strlen(pObj->pName); *pCur != '.'; pCur++ )
             if ( *pCur == '0' || *pCur == '1' )
                 CounterOne++;
         if ( CounterOne )
             Counter += CounterOne - 1;
     }
     return Counter;
 }

static int Io_BlifEstimatePiNum ( Io_BlifMan_t * p )

static

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

Synopsis [Conservatively estimates the number of primary inputs.]

Description []

SideEffects []

SeeAlso []

Definition at line 369 of file ioReadBlifAig.c.

 {
     char * pCur;
     int i, fSpaces;
     int Counter = 0;
     Vec_PtrForEachEntry( char *, p->vInputs, pCur, i )
         for ( fSpaces = 0; *pCur; pCur++ )
         {
             if ( Io_BlifCharIsSpace(*pCur) )
             {
                 if ( !fSpaces )
                     Counter++;
                 fSpaces = 1;
             }
             else
                 fSpaces = 0;
         }
     return Counter;
 }

static void Io_BlifFree ( Io_BlifMan_t * p )

static

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

Synopsis [Frees the BLIF parsing structure.]

Description []

SideEffects []

SeeAlso []

Definition at line 202 of file ioReadBlifAig.c.

 {
     if ( p->pAig )
         Abc_NtkDelete( p->pAig );
     if ( p->pBuffer )  ABC_FREE( p->pBuffer );
     if ( p->pObjects ) ABC_FREE( p->pObjects );
     if ( p->pTable )   ABC_FREE( p->pTable );
     Vec_PtrFree( p->vLines );
     Vec_PtrFree( p->vInputs );
     Vec_PtrFree( p->vOutputs );
     Vec_PtrFree( p->vLatches );
     Vec_PtrFree( p->vNames );
     Vec_PtrFree( p->vTokens );
     Vec_PtrFree( p->vPis );
     Vec_PtrFree( p->vPos );
     Vec_PtrFree( p->vLis );
     Vec_PtrFree( p->vLos );
     ABC_FREE( p );
 }

static int Io_BlifGetLine	(	Io_BlifMan_t *	p,
		char *	pToken
	)

static

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

Synopsis [Returns the 1-based number of the line in which the token occurs.]

Description []

SideEffects []

SeeAlso []

Definition at line 348 of file ioReadBlifAig.c.

 {
     char * pLine;
     int i;
     Vec_PtrForEachEntry( char *, p->vLines, pLine, i )
         if ( pToken < pLine )
             return i;
     return -1;
 }

static Io_BlifObj_t* Io_BlifHashFindOrAdd	(	Io_BlifMan_t *	p,
		char *	pName
	)

static

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

Synopsis [Finds or add the given name to the table.]

Description []

SideEffects []

SeeAlso []

Definition at line 277 of file ioReadBlifAig.c.

 {
     Io_BlifObj_t ** ppEntry;
     ppEntry = Io_BlifHashLookup( p, pName );
     if ( *ppEntry == NULL )
     {
         assert( p->iObjNext < p->nObjects ); 
         *ppEntry = p->pObjects + p->iObjNext++;
         (*ppEntry)->pName = pName;
     }
     return *ppEntry;
 }

static Io_BlifObj_t** Io_BlifHashLookup	(	Io_BlifMan_t *	p,
		char *	pName
	)

static

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

Synopsis [Checks if the given name exists in the table.]

Description []

SideEffects []

SeeAlso []

Definition at line 257 of file ioReadBlifAig.c.

 {
     Io_BlifObj_t ** ppEntry;
     for ( ppEntry = p->pTable + Io_BlifHashString(pName, p->nTableSize); *ppEntry; ppEntry = &(*ppEntry)->pNext )
         if ( !strcmp((*ppEntry)->pName, pName) )
             return ppEntry;
     return ppEntry;
 }

static unsigned Io_BlifHashString	(	char *	pName,
		int	TableSize
	)

static

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

Synopsis [Hashing for character strings.]

Description []

SideEffects []

SeeAlso []

Definition at line 234 of file ioReadBlifAig.c.

 {
     static int s_Primes[10] = { 
         1291, 1699, 2357, 4177, 5147, 
         5647, 6343, 7103, 7873, 8147
     };
     unsigned i, Key = 0;
     for ( i = 0; pName[i] != '\0'; i++ )
         Key ^= s_Primes[i%10]*pName[i]*pName[i];
     return Key % TableSize;
 }

static char * Io_BlifLoadFile ( char * pFileName )

static

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

Synopsis [Reads the file into a character buffer.]

Description []

SideEffects []

SeeAlso []

Definition at line 431 of file ioReadBlifAig.c.

 {
     FILE * pFile;
     int nFileSize;
     char * pContents;
     int RetValue;
     pFile = fopen( pFileName, "rb" );
     if ( pFile == NULL )
     {
         printf( "Io_BlifLoadFile(): 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_BlifLoadFile(): 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;
 }

static Abc_Ntk_t * Io_BlifParse ( Io_BlifMan_t * p )

static

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

Synopsis [Reads the AIG in the binary AIGER format.]

Description []

SideEffects []

SeeAlso []

Definition at line 567 of file ioReadBlifAig.c.

 {
     Abc_Ntk_t * pAig;
     char * pLine;
     int i;
     // parse the model
     if ( !Io_BlifParseModel( p, p->pModel ) )
         return NULL;
     // parse the inputs
     Vec_PtrForEachEntry( char *, p->vInputs, pLine, i )
         if ( !Io_BlifParseInputs( p, pLine ) )
             return NULL;
     // parse the outputs
     Vec_PtrForEachEntry( char *, p->vOutputs, pLine, i )
         if ( !Io_BlifParseOutputs( p, pLine ) )
             return NULL;
     // parse the latches
     Vec_PtrForEachEntry( char *, p->vLatches, pLine, i )
         if ( !Io_BlifParseLatch( p, pLine ) )
             return NULL;
     // parse the nodes
     Vec_PtrForEachEntry( char *, p->vNames, pLine, i )
         if ( !Io_BlifParseNames( p, pLine ) )
             return NULL;
     // reconstruct the network from the parsed data
     if ( !Io_BlifParseConstruct( p ) )
         return NULL;
     // return the network
     pAig = p->pAig;
     p->pAig = NULL;
     return pAig;
 }

static int Io_BlifParseConstruct ( Io_BlifMan_t * p )

static

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

Synopsis [Constructs the AIG from the file parsing info.]

Description []

SideEffects []

SeeAlso []

Definition at line 944 of file ioReadBlifAig.c.

 {
     Abc_Ntk_t * pAig;
     Io_BlifObj_t * pObjIo, * pObjIoInput;
     Abc_Obj_t * pObj, * pLatch;
     int i;
     // allocate the empty AIG
     pAig = p->pAig = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
     pAig->pName = Extra_UtilStrsav( p->pModel );
     pAig->pSpec = Extra_UtilStrsav( p->pFileName );
     // create PIs
     Vec_PtrForEachEntry( Io_BlifObj_t *, p->vPis, pObjIo, i )
     {
         pObj = Abc_NtkCreatePi( pAig );
         Abc_ObjAssignName( pObj, pObjIo->pName, NULL );
         pObjIo->pEquiv = pObj;
     }
     // create POs
     Vec_PtrForEachEntry( Io_BlifObj_t *, p->vPos, pObjIo, i )
     {
         pObj = Abc_NtkCreatePo( pAig );
         Abc_ObjAssignName( pObj, pObjIo->pName, NULL );
     }
     // create latches
     Vec_PtrForEachEntry( Io_BlifObj_t *, p->vLos, pObjIo, i )
     {
         // add the latch input terminal
         pObj = Abc_NtkCreateBi( pAig );
         pObjIoInput = (Io_BlifObj_t *)Vec_PtrEntry( p->vLis, i );
         Abc_ObjAssignName( pObj, pObjIoInput->pName, NULL );
         
         // add the latch box
         pLatch = Abc_NtkCreateLatch( pAig );
         pLatch->pData = (void *)(ABC_PTRUINT_T)pObjIo->Init;
         Abc_ObjAssignName( pLatch, pObjIo->pName, "L" );
         Abc_ObjAddFanin( pLatch, pObj  );
 
         // add the latch output terminal
         pObj = Abc_NtkCreateBo( pAig );
         Abc_ObjAssignName( pObj, pObjIo->pName, NULL );
         Abc_ObjAddFanin( pObj, pLatch );
         // set the value of the latch output
 //        pObjIo->pEquiv = Abc_ObjNotCond( pObj, pObjIo->Init );
         pObjIo->pEquiv = pObj;
     }
     // traverse the nodes from the POs
     Vec_PtrForEachEntry( Io_BlifObj_t *, p->vPos, pObjIo, i )
     {
         pObj = Io_BlifParseConstruct_rec( p, pObjIo->pName );
         if ( pObj == NULL )
             return 0;
         Abc_ObjAddFanin( Abc_NtkPo(p->pAig, i), pObj );
     }
     // traverse the nodes from the latch inputs
     Vec_PtrForEachEntry( Io_BlifObj_t *, p->vLis, pObjIo, i )
     {
         pObj = Io_BlifParseConstruct_rec( p, pObjIo->pName );
         if ( pObj == NULL )
             return 0;
 //        pObj = Abc_ObjNotCond( pObj, pObjIo->Init );
         Abc_ObjAddFanin( Abc_ObjFanin0(Abc_NtkBox(p->pAig, i)), pObj );
     }
     p->nTablesLeft = Vec_PtrSize(p->vNames) - p->nTablesRead; 
     if ( p->nTablesLeft ) 
         printf( "The number of dangling tables = %d.\n", p->nTablesLeft );
     printf( "AND nodes = %6d.  Estimate = %6d.\n", Abc_NtkNodeNum(p->pAig), Io_BlifEstimateAndNum(p) );
     return 1;
 }

static Abc_Obj_t* Io_BlifParseConstruct_rec	(	Io_BlifMan_t *	p,
		char *	pName
	)

static

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

Synopsis [Constructs the AIG from the file parsing info.]

Description []

SideEffects []

SeeAlso []

Definition at line 886 of file ioReadBlifAig.c.

 {
     Vec_Ptr_t * vFanins;
     Abc_Obj_t * pFaninAbc;
     Io_BlifObj_t * pObjIo;
     char * pNameFanin;
     int i;
     // get the IO object with this name
     pObjIo = *Io_BlifHashLookup( p, pName );
     if ( pObjIo == NULL )
     {
         sprintf( p->sError, "Line %d: Signal (%s) is not defined as a table.", Io_BlifGetLine(p, pName), pName );
         return NULL;
     }
     // loop detection
     if ( pObjIo->fLoop )
     {
         sprintf( p->sError, "Line %d: Signal (%s) appears twice on a combinational path.", Io_BlifGetLine(p, pName), pName );
         return NULL;
     }
     // check if the AIG is already constructed
     if ( pObjIo->pEquiv )
         return (Abc_Obj_t *)pObjIo->pEquiv;
     // mark this node on the path
     pObjIo->fLoop = 1;
     // construct the AIGs for the fanins
     vFanins = Vec_PtrAlloc( 8 );
     Io_BlifCollectTokens( vFanins, pObjIo->pName - pObjIo->Offset, pObjIo->pName );
     Vec_PtrForEachEntry( char *, vFanins, pNameFanin, i )
     {
         pFaninAbc = Io_BlifParseConstruct_rec( p, pNameFanin );
         if ( pFaninAbc == NULL )
         {
             Vec_PtrFree( vFanins );
             return NULL;
         }
         Vec_PtrWriteEntry( vFanins, i, pFaninAbc );
     }
     // construct the node
     pObjIo->pEquiv = Io_BlifParseTable( p, pObjIo->pName + strlen(pObjIo->pName), vFanins );
     Vec_PtrFree( vFanins );
     // unmark this node on the path
     pObjIo->fLoop = 0;
     // remember the new node
     return (Abc_Obj_t *)pObjIo->pEquiv;
 }

static int Io_BlifParseInputs	(	Io_BlifMan_t *	p,
		char *	pLine
	)

static

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

Synopsis [Parses the inputs line.]

Description []

SideEffects []

SeeAlso []

Definition at line 637 of file ioReadBlifAig.c.

 {
     Io_BlifObj_t * pObj;
     char * pToken;
     int i;
     Io_BlifSplitIntoTokens( p->vTokens, pLine, '\0' );
     pToken = (char *)Vec_PtrEntry(p->vTokens, 0);
     assert( !strcmp(pToken, "inputs") );
     Vec_PtrForEachEntryStart( char *, p->vTokens, pToken, i, 1 )
     {
         pObj = Io_BlifHashFindOrAdd( p, pToken );
         if ( pObj->fPi )
         {
             sprintf( p->sError, "Line %d: Primary input (%s) is defined more than once.", Io_BlifGetLine(p, pToken), pToken );
             return 0;
         }
         pObj->fPi = 1;
         Vec_PtrPush( p->vPis, pObj );
     }
     return 1;
 }

static int Io_BlifParseLatch	(	Io_BlifMan_t *	p,
		char *	pLine
	)

static

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

Synopsis [Parses the latches line.]

Description []

SideEffects []

SeeAlso []

Definition at line 700 of file ioReadBlifAig.c.

 {
     Io_BlifObj_t * pObj;
     char * pToken;
     int Init;
     Io_BlifSplitIntoTokens( p->vTokens, pLine, '\0' );
     pToken = (char *)Vec_PtrEntry(p->vTokens,0);
     assert( !strcmp(pToken, "latch") );
     if ( Vec_PtrSize(p->vTokens) < 3 )
     {
         sprintf( p->sError, "Line %d: Latch does not have input name and output name.", Io_BlifGetLine(p, pToken) );
         return 0;
     }
     // get initial value
     if ( Vec_PtrSize(p->vTokens) > 3 )
         Init = atoi( (char *)Vec_PtrEntry(p->vTokens,3) );
     else
         Init = 2;
     if ( Init < 0 || Init > 2 )
     {
         sprintf( p->sError, "Line %d: Initial state of the latch is incorrect (%s).", Io_BlifGetLine(p, pToken), (char*)Vec_PtrEntry(p->vTokens,3) );
         return 0;
     }
     if ( Init == 0 )
         Init = IO_BLIF_INIT_ZERO;
     else if ( Init == 1 )
         Init = IO_BLIF_INIT_ONE;
     else // if ( Init == 2 )
         Init = IO_BLIF_INIT_DC;
     // get latch input
     pObj = Io_BlifHashFindOrAdd( p, (char *)Vec_PtrEntry(p->vTokens,1) );
     pObj->fLi = 1;
     Vec_PtrPush( p->vLis, pObj );
     pObj->Init = Init;
     // get latch output
     pObj = Io_BlifHashFindOrAdd( p, (char *)Vec_PtrEntry(p->vTokens,2) );
     if ( pObj->fPi )
     {
         sprintf( p->sError, "Line %d: Primary input (%s) is also defined latch output.", Io_BlifGetLine(p, pToken), (char*)Vec_PtrEntry(p->vTokens,2) );
         return 0;
     }
     if ( pObj->fLo )
     {
         sprintf( p->sError, "Line %d: Latch output (%s) is defined as the output of another latch.", Io_BlifGetLine(p, pToken), (char*)Vec_PtrEntry(p->vTokens,2) );
         return 0;
     }
     pObj->fLo = 1;
     Vec_PtrPush( p->vLos, pObj );
     pObj->Init = Init;
     return 1;
 }

static int Io_BlifParseModel	(	Io_BlifMan_t *	p,
		char *	pLine
	)

static

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

Synopsis [Parses the model line.]

Description []

SideEffects []

SeeAlso []

Definition at line 611 of file ioReadBlifAig.c.

 {
     char * pToken;
     Io_BlifSplitIntoTokens( p->vTokens, pLine, '\0' );
     pToken = (char *)Vec_PtrEntry( p->vTokens, 0 );
     assert( !strcmp(pToken, "model") );
     if ( Vec_PtrSize(p->vTokens) != 2 )
     {
         sprintf( p->sError, "Line %d: Model line has %d entries while it should have 2.", Io_BlifGetLine(p, pToken), Vec_PtrSize(p->vTokens) );
         return 0;
     }
     p->pModel = (char *)Vec_PtrEntry( p->vTokens, 1 );
     return 1;
 }

static int Io_BlifParseNames	(	Io_BlifMan_t *	p,
		char *	pLine
	)

static

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

Synopsis [Parses the nodes line.]

Description []

SideEffects []

SeeAlso []

Definition at line 763 of file ioReadBlifAig.c.

 {
     Io_BlifObj_t * pObj;
     char * pName;
     Io_BlifSplitIntoTokens( p->vTokens, pLine, '\0' );
     assert( !strcmp((char *)Vec_PtrEntry(p->vTokens,0), "names") );
     pName = (char *)Vec_PtrEntryLast( p->vTokens );
     pObj = Io_BlifHashFindOrAdd( p, pName );
     if ( pObj->fPi )
     {
         sprintf( p->sError, "Line %d: Primary input (%s) has a table.", Io_BlifGetLine(p, pName), pName );
         return 0;
     }
     if ( pObj->fLo )
     {
         sprintf( p->sError, "Line %d: Latch output (%s) has a table.", Io_BlifGetLine(p, pName), pName );
         return 0;
     }
     if ( pObj->fDef )
     {
         sprintf( p->sError, "Line %d: Signal (%s) is defined more than once.", Io_BlifGetLine(p, pName), pName );
         return 0;
     }
     pObj->fDef = 1;
     // remember offset to the first fanin name
     pObj->pName = pName;
     pObj->Offset = pObj->pName - (char *)Vec_PtrEntry(p->vTokens,1);
     return 1;
 }

static int Io_BlifParseOutputs	(	Io_BlifMan_t *	p,
		char *	pLine
	)

static

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

Synopsis [Parses the outputs line.]

Description []

SideEffects []

SeeAlso []

Definition at line 670 of file ioReadBlifAig.c.

 {
     Io_BlifObj_t * pObj;
     char * pToken;
     int i;
     Io_BlifSplitIntoTokens( p->vTokens, pLine, '\0' );
     pToken = (char *)Vec_PtrEntry(p->vTokens, 0);
     assert( !strcmp(pToken, "outputs") );
     Vec_PtrForEachEntryStart( char *, p->vTokens, pToken, i, 1 )
     {
         pObj = Io_BlifHashFindOrAdd( p, pToken );
         if ( pObj->fPo )
             fprintf( stdout, "Line %d: Primary output (%s) is defined more than once (warning only).\n", Io_BlifGetLine(p, pToken), pToken );
         pObj->fPo = 1;
         Vec_PtrPush( p->vPos, pObj );
     }
     return 1;
 }

static Abc_Obj_t* Io_BlifParseTable	(	Io_BlifMan_t *	p,
		char *	pTable,
		Vec_Ptr_t *	vFanins
	)

static

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

Synopsis [Constructs the AIG from the file parsing info.]

Description []

SideEffects []

SeeAlso []

Definition at line 805 of file ioReadBlifAig.c.

 {
     char * pProduct, * pOutput;
     Abc_Obj_t * pRes, * pCube;
     int i, k, Polarity = -1;
 
     p->nTablesRead++;
     // get the tokens
     Io_BlifSplitIntoTokens( p->vTokens, pTable, '.' );
     if ( Vec_PtrSize(p->vTokens) == 0 )
         return Abc_ObjNot( Abc_AigConst1(p->pAig) );
     if ( Vec_PtrSize(p->vTokens) == 1 )
     {
         pOutput = (char *)Vec_PtrEntry( p->vTokens, 0 );
         if ( ((pOutput[0] - '0') & 0x8E) || pOutput[1] )
         {
             sprintf( p->sError, "Line %d: Constant table has wrong output value (%s).", Io_BlifGetLine(p, pOutput), pOutput );
             return NULL;
         }
         return Abc_ObjNotCond( Abc_AigConst1(p->pAig), pOutput[0] == '0' );
     }
     pProduct = (char *)Vec_PtrEntry( p->vTokens, 0 );
     if ( Vec_PtrSize(p->vTokens) % 2 == 1 )
     {
         sprintf( p->sError, "Line %d: Table has odd number of tokens (%d).", Io_BlifGetLine(p, pProduct), Vec_PtrSize(p->vTokens) );
         return NULL;
     }
     // parse the table
     pRes = Abc_ObjNot( Abc_AigConst1(p->pAig) );
     for ( i = 0; i < Vec_PtrSize(p->vTokens)/2; i++ )
     {
         pProduct = (char *)Vec_PtrEntry( p->vTokens, 2*i + 0 );
         pOutput  = (char *)Vec_PtrEntry( p->vTokens, 2*i + 1 );
         if ( strlen(pProduct) != (unsigned)Vec_PtrSize(vFanins) )
         {
             sprintf( p->sError, "Line %d: Cube (%s) has size different from the fanin count (%d).", Io_BlifGetLine(p, pProduct), pProduct, Vec_PtrSize(vFanins) );
             return NULL;
         }
         if ( ((pOutput[0] - '0') & 0x8E) || pOutput[1] )
         {
             sprintf( p->sError, "Line %d: Output value (%s) is incorrect.", Io_BlifGetLine(p, pProduct), pOutput );
             return NULL;
         }
         if ( Polarity == -1 )
             Polarity = pOutput[0] - '0';
         else if ( Polarity != pOutput[0] - '0' )
         {
             sprintf( p->sError, "Line %d: Output value (%s) differs from the value in the first line of the table (%d).", Io_BlifGetLine(p, pProduct), pOutput, Polarity );
             return NULL;
         }
         // parse one product product
         pCube = Abc_AigConst1(p->pAig);
         for ( k = 0; pProduct[k]; k++ )
         {
             if ( pProduct[k] == '0' )
                 pCube = Abc_AigAnd( (Abc_Aig_t *)p->pAig->pManFunc, pCube, Abc_ObjNot((Abc_Obj_t *)Vec_PtrEntry(vFanins,k)) );
             else if ( pProduct[k] == '1' )
                 pCube = Abc_AigAnd( (Abc_Aig_t *)p->pAig->pManFunc, pCube, (Abc_Obj_t *)Vec_PtrEntry(vFanins,k) );
             else if ( pProduct[k] != '-' )
             {
                 sprintf( p->sError, "Line %d: Product term (%s) contains character (%c).", Io_BlifGetLine(p, pProduct), pProduct, pProduct[k] );
                 return NULL;
             }
         }
         pRes = Abc_AigOr( (Abc_Aig_t *)p->pAig->pManFunc, pRes, pCube );
     }
     pRes = Abc_ObjNotCond( pRes, Polarity == 0 );
     return pRes;
 }

static void Io_BlifReadPreparse ( Io_BlifMan_t * p )

static

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 []

Definition at line 478 of file ioReadBlifAig.c.

 {
     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;
             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_BlifCharIsSpace(*pPrev) )
                 break;
         // if it is the line extender, overwrite it with spaces
         if ( *pPrev == '\\' )
         {
             for ( ; *pPrev; pPrev++ )
                 *pPrev = ' ';
             *pPrev = ' ';
             continue;
         }
         // skip spaces at the beginning of the line
         while ( Io_BlifCharIsSpace(*pCur++) );
         // parse directives
         if ( *(pCur-1) != '.' )
             continue;
         if ( !strncmp(pCur, "names", 5) )
             Vec_PtrPush( p->vNames, pCur );
         else if ( !strncmp(pCur, "latch", 5) )
             Vec_PtrPush( p->vLatches, pCur );
         else if ( !strncmp(pCur, "inputs", 6) )
             Vec_PtrPush( p->vInputs, pCur );
         else if ( !strncmp(pCur, "outputs", 7) )
             Vec_PtrPush( p->vOutputs, pCur );
         else if ( !strncmp(pCur, "model", 5) ) 
             p->pModel = pCur;
         else if ( !strncmp(pCur, "end", 3) || !strncmp(pCur, "exdc", 4) )
             break;
         else
         {
             pCur--;
             if ( pCur[strlen(pCur)-1] == '\r' )
                 pCur[strlen(pCur)-1] = 0;
             fprintf( stdout, "Line %d: Skipping line \"%s\".\n", Io_BlifGetLine(p, pCur), pCur );
         }
     }
 
     // count the number of objects
     p->nObjects = Io_BlifEstimatePiNum(p) + Vec_PtrSize(p->vLatches) + Vec_PtrSize(p->vNames) + 512;
 
     // allocate memory for objects
     p->pObjects = ABC_ALLOC( Io_BlifObj_t, p->nObjects );
     memset( p->pObjects, 0, p->nObjects * sizeof(Io_BlifObj_t) );
 
     // allocate memory for the hash table
     p->nTableSize = p->nObjects/2 + 1;
     p->pTable = ABC_ALLOC( Io_BlifObj_t *, p->nTableSize );
     memset( p->pTable, 0, p->nTableSize * sizeof(Io_BlifObj_t *) );
 }

static void Io_BlifSplitIntoTokens	(	Vec_Ptr_t *	vTokens,
		char *	pLine,
		char	Stop
	)

static

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

Synopsis [Splits the line into tokens.]

Description []

SideEffects []

SeeAlso []

Definition at line 326 of file ioReadBlifAig.c.

 {
     char * pCur;
     // clear spaces
     for ( pCur = pLine; *pCur != Stop; pCur++ )
         if ( Io_BlifCharIsSpace(*pCur) )
             *pCur = 0;
     // collect tokens
     Io_BlifCollectTokens( vTokens, pLine, pCur );
 }

Abc_Ntk_t* Io_ReadBlifAsAig	(	char *	pFileName,
		int	fCheck
	)

FUNCTION DEFINITIONS ///.

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

Synopsis [Reads the network from the BLIF file as an AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 118 of file ioReadBlifAig.c.

 {
     FILE * pFile;
     Io_BlifMan_t * p;
     Abc_Ntk_t * pAig;
 
     // check that the file is available
     pFile = fopen( pFileName, "rb" );
     if ( pFile == NULL )
     {
         printf( "Io_Blif(): The file is unavailable (absent or open).\n" );
         return 0;
     }
     fclose( pFile );
 
     // start the file reader
     p = Io_BlifAlloc();
     p->pFileName = pFileName;
     p->pBuffer   = Io_BlifLoadFile( pFileName );
     if ( p->pBuffer == NULL )
     {
         Io_BlifFree( p );
         return NULL;
     }
     // prepare the file for parsing
     Io_BlifReadPreparse( p );
     // construct the network
     pAig = Io_BlifParse( p );
     if ( p->sError[0] )
         fprintf( stdout, "%s\n", p->sError );
     if ( pAig == NULL )
         return NULL;
     Io_BlifFree( p );
 
     // make sure that everything is okay with the network structure
     if ( fCheck && !Abc_NtkCheckRead( pAig ) )
     {
         printf( "Io_Blif: The network check has failed.\n" );
         Abc_NtkDelete( pAig );
         return NULL;
     }
     return pAig;
 }

Data Structures

Typedefs

Enumerations

Functions

Typedef Documentation

Enumeration Type Documentation

Function Documentation