ruby_abc 0.0.6 → 0.1.0

data/ext/abc/src/base/io/ioReadBlifAig.c

@@ -1,1019 +0,0 @@
-/**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 $]
-
-***********************************************************************/
-
-#include "base/abc/abc.h"
-#include "misc/vec/vecPtr.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-// latch initial values
-typedef enum { 
-    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;
-
-typedef struct Io_BlifObj_t_ Io_BlifObj_t;  // parsing object
-struct Io_BlifObj_t_
-{
-    unsigned             fPi    :  1;  // the object is a primary input
-    unsigned             fPo    :  1;  // the object is a primary output
-    unsigned             fLi    :  1;  // the object is a latch input
-    unsigned             fLo    :  1;  // the object is a latch output
-    unsigned             fDef   :  1;  // the object is defined as a table (node, PO, LI)
-    unsigned             fLoop  :  1;  // flag for loop detection
-    unsigned             Init   :  2;  // the latch initial state
-    unsigned             Offset : 24;  // temporary number
-    char *               pName;        // the name of this object
-    void *               pEquiv;       // the AIG node representing this line    
-    Io_BlifObj_t *       pNext;        // the next obj in the hash table
-};
-
-typedef struct Io_BlifMan_t_ Io_BlifMan_t;  // parsing manager
-struct Io_BlifMan_t_
-{
-    // general info about file
-    char *               pFileName;    // the name of the file
-    char *               pBuffer;      // the begining of the file buffer
-    Vec_Ptr_t *          vLines;       // the line beginnings
-    // temporary objects
-    Io_BlifObj_t *       pObjects;     // the storage for objects
-    int                  nObjects;     // the number of objects allocated
-    int                  iObjNext;     // the next free object
-    // file lines
-    char *               pModel;       // .model line
-    Vec_Ptr_t *          vInputs;      // .inputs lines
-    Vec_Ptr_t *          vOutputs;     // .outputs lines
-    Vec_Ptr_t *          vLatches;     // .latches lines
-    Vec_Ptr_t *          vNames;       // .names lines
-    // network objects
-    Vec_Ptr_t *          vPis;         // the PI structures
-    Vec_Ptr_t *          vPos;         // the PO structures
-    Vec_Ptr_t *          vLis;         // the LI structures
-    Vec_Ptr_t *          vLos;         // the LO structures
-    // mapping of names into objects
-    Io_BlifObj_t **      pTable;       // the hash table
-    int                  nTableSize;   // the hash table size
-    // current processing info
-    Abc_Ntk_t *          pAig;         // the network under construction
-    Vec_Ptr_t *          vTokens;      // the current tokens
-    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_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 ) { return s == ' ' || s == '\t' || s == '\r' || s == '\n';  }
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Reads the network from the BLIF file as an AIG.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Abc_Ntk_t * Io_ReadBlifAsAig( char * pFileName, int fCheck )
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Allocates the BLIF parsing structure.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static Io_BlifMan_t * Io_BlifAlloc()
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Frees the BLIF parsing structure.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static void Io_BlifFree( Io_BlifMan_t * p )
-{
-    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 );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Hashing for character strings.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static unsigned Io_BlifHashString( char * pName, int TableSize ) 
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Checks if the given name exists in the table.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static Io_BlifObj_t ** Io_BlifHashLookup( Io_BlifMan_t * p, char * pName )
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Finds or add the given name to the table.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static Io_BlifObj_t * Io_BlifHashFindOrAdd( Io_BlifMan_t * p, char * pName )
-{
-    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;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Collects the already split tokens.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static void Io_BlifCollectTokens( 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_BlifSplitIntoTokens( Vec_Ptr_t * vTokens, char * pLine, char Stop )
-{
-    char * pCur;
-    // clear spaces
-    for ( pCur = pLine; *pCur != Stop; pCur++ )
-        if ( Io_BlifCharIsSpace(*pCur) )
-            *pCur = 0;
-    // collect tokens
-    Io_BlifCollectTokens( vTokens, pLine, pCur );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the 1-based number of the line in which the token occurs.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Io_BlifGetLine( Io_BlifMan_t * p, char * pToken )
-{
-    char * pLine;
-    int i;
-    Vec_PtrForEachEntry( char *, p->vLines, pLine, i )
-        if ( pToken < pLine )
-            return i;
-    return -1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Conservatively estimates the number of primary inputs.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Io_BlifEstimatePiNum( Io_BlifMan_t * p )
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Conservatively estimates the number of AIG nodes.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Io_BlifEstimateAndNum( Io_BlifMan_t * p )
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Reads the file into a character buffer.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static char * Io_BlifLoadFile( char * pFileName )
-{
-    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;
-}
-
-/**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_BlifReadPreparse( Io_BlifMan_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;
-            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 *) );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Reads the AIG in the binary AIGER format.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static Abc_Ntk_t * Io_BlifParse( Io_BlifMan_t * p )
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Parses the model line.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Io_BlifParseModel( Io_BlifMan_t * p, char * pLine )
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Parses the inputs line.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Io_BlifParseInputs( Io_BlifMan_t * p, char * pLine )
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Parses the outputs line.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Io_BlifParseOutputs( Io_BlifMan_t * p, char * pLine )
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Parses the latches line.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Io_BlifParseLatch( Io_BlifMan_t * p, char * pLine )
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Parses the nodes line.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Io_BlifParseNames( Io_BlifMan_t * p, char * pLine )
-{
-    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;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Constructs the AIG from the file parsing info.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static Abc_Obj_t * Io_BlifParseTable( Io_BlifMan_t * p, char * pTable, Vec_Ptr_t * vFanins )
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Constructs the AIG from the file parsing info.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static Abc_Obj_t * Io_BlifParseConstruct_rec( Io_BlifMan_t * p, char * pName )
-{
-    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;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Constructs the AIG from the file parsing info.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Io_BlifParseConstruct( Io_BlifMan_t * p )
-{
-    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;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-