Version abc80130

1 files changed, 0 insertions, 1163 deletions

diff --git a/src/aig/ntl/ntlReadBlif.c b/src/aig/ntl/ntlReadBlif.c
deleted file mode 100644
index d085b5e6..00000000
--- a/src/aig/ntl/ntlReadBlif.c
+++ /dev/null
@@ -1,1163 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [ntlReadBlif.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Command processing package.]
-
-  Synopsis    [Procedures to read BLIF file.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - January 8, 2007.]
-
-  Revision    [$Id: ntlReadBlif.c,v 1.00 2007/01/08 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "ntl.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Ioa_ReadMod_t_ Ioa_ReadMod_t;   // parsing model
-typedef struct Ioa_ReadMan_t_ Ioa_ReadMan_t;   // parsing manager
-
-struct Ioa_ReadMod_t_
-{
-    // file lines
-    char *               pFirst;       // .model line
-    Vec_Ptr_t *          vInputs;      // .inputs lines
-    Vec_Ptr_t *          vOutputs;     // .outputs lines
-    Vec_Ptr_t *          vLatches;     // .latch lines
-    Vec_Ptr_t *          vNames;       // .names lines
-    Vec_Ptr_t *          vSubckts;     // .subckt lines
-    Vec_Ptr_t *          vDelays;      // .delay lines
-    Vec_Ptr_t *          vArrivals;    // .input_arrival lines
-    Vec_Ptr_t *          vRequireds;   // .output_required lines
-    int                  fBlackBox;    // indicates blackbox model
-    // the resulting network
-    Ntl_Mod_t *          pNtk;   
-    // the parent manager
-    Ioa_ReadMan_t *      pMan;         
-};
-
-struct Ioa_ReadMan_t_
-{
-    // general info about file
-    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
-    Ntl_Man_t *          pDesign;      // the design under construction
-    // intermediate storage for models
-    Vec_Ptr_t *          vModels;      // vector of models
-    Ioa_ReadMod_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 Ioa_ReadMan_t *   Ioa_ReadAlloc();
-static void              Ioa_ReadFree( Ioa_ReadMan_t * p );
-static Ioa_ReadMod_t *   Ioa_ReadModAlloc();
-static void              Ioa_ReadModFree( Ioa_ReadMod_t * p );
-static char *            Ioa_ReadLoadFile( char * pFileName );
-static void              Ioa_ReadReadPreparse( Ioa_ReadMan_t * p );
-static int               Ioa_ReadReadInterfaces( Ioa_ReadMan_t * p );
-static Ntl_Man_t *       Ioa_ReadParse( Ioa_ReadMan_t * p );
-static int               Ioa_ReadParseLineModel( Ioa_ReadMod_t * p, char * pLine );
-static int               Ioa_ReadParseLineInputs( Ioa_ReadMod_t * p, char * pLine );
-static int               Ioa_ReadParseLineOutputs( Ioa_ReadMod_t * p, char * pLine );
-static int               Ioa_ReadParseLineLatch( Ioa_ReadMod_t * p, char * pLine );
-static int               Ioa_ReadParseLineSubckt( Ioa_ReadMod_t * p, char * pLine );
-static int               Ioa_ReadParseLineDelay( Ioa_ReadMod_t * p, char * pLine );
-static int               Ioa_ReadParseLineTimes( Ioa_ReadMod_t * p, char * pLine, int fOutput );
-static int               Ioa_ReadParseLineNamesBlif( Ioa_ReadMod_t * p, char * pLine );
-
-static int               Ioa_ReadCharIsSpace( char s )   { return s == ' ' || s == '\t' || s == '\r' || s == '\n';             }
-static int               Ioa_ReadCharIsSopSymb( char s ) { return s == '0' || s == '1' || s == '-' || s == '\r' || s == '\n';  }
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Reads the network from the BLIF file.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Ntl_Man_t * Ioa_ReadBlif( char * pFileName, int fCheck )
-{
-    FILE * pFile;
-    Ioa_ReadMan_t * p;
-    Ntl_Mod_t * pNtk;
-    Ntl_Man_t * pDesign;
-    int i;
-
-    // check that the file is available
-    pFile = fopen( pFileName, "rb" );
-    if ( pFile == NULL )
-    {
-        printf( "Ioa_ReadBlif(): The file is unavailable (absent or open).\n" );
-        return 0;
-    }
-    fclose( pFile );
-
-    // start the file reader
-    p = Ioa_ReadAlloc();
-    p->pFileName = pFileName;
-    p->pBuffer   = Ioa_ReadLoadFile( pFileName );
-    if ( p->pBuffer == NULL )
-    {
-        Ioa_ReadFree( p );
-        return NULL;
-    }
-    // set the design name
-    p->pDesign = Ntl_ManAlloc( pFileName );
-    // prepare the file for parsing
-    Ioa_ReadReadPreparse( p );
-    // parse interfaces of each network
-    if ( !Ioa_ReadReadInterfaces( p ) )
-    {
-        if ( p->sError[0] )
-            fprintf( stdout, "%s\n", p->sError );
-        Ioa_ReadFree( p );
-        return NULL;
-    }
-    // construct the network
-    pDesign = Ioa_ReadParse( p );
-    if ( p->sError[0] )
-        fprintf( stdout, "%s\n", p->sError );
-    if ( pDesign == NULL )
-    {
-        Ioa_ReadFree( p );
-        return NULL;
-    }
-    p->pDesign = NULL;
-    Ioa_ReadFree( p );
-// pDesign should be linked to all models of the design
-
-    // make sure that everything is okay with the network structure
-    if ( fCheck )
-    {
-        // check individual models
-        Vec_PtrForEachEntry( pDesign->vModels, pNtk, i )
-        {
-            if ( !Ntl_ModelCheck( pNtk ) )
-            {
-                printf( "Ioa_ReadBlif: The network check has failed for network %s.\n", pNtk->pName );
-                Ntl_ManFree( pDesign );
-                return NULL;
-            }
-        }
-        // check the hierarchy
-        if ( !Ntl_ManCheck( pDesign ) )
-        {
-            printf( "Ioa_ReadBlif: The hierarchy check has failed for design %s.\n", pDesign->pName );
-            Ntl_ManFree( pDesign );
-            return NULL;
-        }
-
-    }
-//Ioa_WriteBlif( pDesign, "_temp_.blif" );
-    return pDesign;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Allocates the BLIF parsing structure.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static Ioa_ReadMan_t * Ioa_ReadAlloc()
-{
-    Ioa_ReadMan_t * p;
-    p = ALLOC( Ioa_ReadMan_t, 1 );
-    memset( p, 0, sizeof(Ioa_ReadMan_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 Ioa_ReadFree( Ioa_ReadMan_t * p )
-{
-    Ioa_ReadMod_t * pMod;
-    int i;
-    if ( p->pDesign )
-        Ntl_ManFree( p->pDesign );
-    if ( p->pBuffer )  
-        free( p->pBuffer );
-    if ( p->vLines )
-        Vec_PtrFree( p->vLines );
-    if ( p->vModels )
-    {
-        Vec_PtrForEachEntry( p->vModels, pMod, i )
-            Ioa_ReadModFree( pMod );
-        Vec_PtrFree( p->vModels );
-    }
-    Vec_PtrFree( p->vTokens );
-    Vec_PtrFree( p->vTokens2 );
-    Vec_StrFree( p->vFunc );
-    free( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Allocates the BLIF parsing structure for one model.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static Ioa_ReadMod_t * Ioa_ReadModAlloc()
-{
-    Ioa_ReadMod_t * p;
-    p = ALLOC( Ioa_ReadMod_t, 1 );
-    memset( p, 0, sizeof(Ioa_ReadMod_t) );
-    p->vInputs  = Vec_PtrAlloc( 512 );
-    p->vOutputs = Vec_PtrAlloc( 512 );
-    p->vLatches = Vec_PtrAlloc( 512 );
-    p->vNames   = Vec_PtrAlloc( 512 );
-    p->vSubckts = Vec_PtrAlloc( 512 );
-    p->vDelays  = Vec_PtrAlloc( 512 );
-    p->vArrivals  = Vec_PtrAlloc( 512 );
-    p->vRequireds = Vec_PtrAlloc( 512 );
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Deallocates the BLIF parsing structure for one model.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static void Ioa_ReadModFree( Ioa_ReadMod_t * p )
-{
-    Vec_PtrFree( p->vInputs );
-    Vec_PtrFree( p->vOutputs );
-    Vec_PtrFree( p->vLatches );
-    Vec_PtrFree( p->vNames );
-    Vec_PtrFree( p->vSubckts );
-    Vec_PtrFree( p->vDelays );
-    Vec_PtrFree( p->vArrivals );
-    Vec_PtrFree( p->vRequireds );
-    free( p );
-}
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Counts the number of given chars.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Ioa_ReadCountChars( char * pLine, char Char )
-{
-    char * pCur;
-    int Counter = 0;
-    for ( pCur = pLine; *pCur; pCur++ )
-        if ( *pCur == Char )
-            Counter++;
-    return Counter;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collects the already split tokens.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static void Ioa_ReadCollectTokens( 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 Ioa_ReadSplitIntoTokens( Vec_Ptr_t * vTokens, char * pLine, char Stop )
-{
-    char * pCur;
-    // clear spaces
-    for ( pCur = pLine; *pCur != Stop; pCur++ )
-        if ( Ioa_ReadCharIsSpace(*pCur) )
-            *pCur = 0;
-    // collect tokens
-    Ioa_ReadCollectTokens( vTokens, pLine, pCur );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Splits the line into tokens.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static void Ioa_ReadSplitIntoTokensAndClear( Vec_Ptr_t * vTokens, char * pLine, char Stop, char Char )
-{
-    char * pCur;
-    // clear spaces
-    for ( pCur = pLine; *pCur != Stop; pCur++ )
-        if ( Ioa_ReadCharIsSpace(*pCur) || *pCur == Char )
-            *pCur = 0;
-    // collect tokens
-    Ioa_ReadCollectTokens( vTokens, pLine, pCur );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the 1-based number of the line in which the token occurs.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Ioa_ReadGetLine( Ioa_ReadMan_t * p, char * pToken )
-{
-    char * pLine;
-    int i;
-    Vec_PtrForEachEntry( 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 * Ioa_ReadLoadFile( char * pFileName )
-{
-    FILE * pFile;
-    int nFileSize;
-    char * pContents;
-    pFile = fopen( pFileName, "rb" );
-    if ( pFile == NULL )
-    {
-        printf( "Ioa_ReadLoadFile(): The file is unavailable (absent or open).\n" );
-        return NULL;
-    }
-    fseek( pFile, 0, SEEK_END );  
-    nFileSize = ftell( pFile ); 
-    if ( nFileSize == 0 )
-    {
-        printf( "Ioa_ReadLoadFile(): The file is empty.\n" );
-        return NULL;
-    }
-    pContents = 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 Ioa_ReadReadPreparse( Ioa_ReadMan_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( p->vLines, pCur, i )
-    {
-        if ( *pCur == 0 )
-            continue;
-        // find previous non-space character
-        for ( pPrev = pCur - 2; pPrev >= p->pBuffer; pPrev-- )
-            if ( !Ioa_ReadCharIsSpace(*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 ( Ioa_ReadCharIsSpace(*pCur++) );
-        // parse directives
-        if ( *(pCur-1) != '.' )
-            continue;
-        if ( !strncmp(pCur, "names", 5) )
-            Vec_PtrPush( p->pLatest->vNames, pCur );
-        else if ( !strncmp(pCur, "latch", 5) )
-            Vec_PtrPush( p->pLatest->vLatches, 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, "delay", 5) )
-            Vec_PtrPush( p->pLatest->vDelays, pCur );
-        else if ( !strncmp(pCur, "input_arrival", 13) )
-            Vec_PtrPush( p->pLatest->vArrivals, pCur );
-        else if ( !strncmp(pCur, "output_required", 15) )
-            Vec_PtrPush( p->pLatest->vRequireds, pCur );
-        else if ( !strncmp(pCur, "blackbox", 8) )
-            p->pLatest->fBlackBox = 1;
-        else if ( !strncmp(pCur, "model", 5) ) 
-        {
-            p->pLatest = Ioa_ReadModAlloc();
-            p->pLatest->pFirst = 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", Ioa_ReadGetLine(p, pCur) );
-            break;
-        }
-        else
-        {
-            pCur--;
-            if ( pCur[strlen(pCur)-1] == '\r' )
-                pCur[strlen(pCur)-1] = 0;
-            fprintf( stdout, "Line %d: Skipping line \"%s\".\n", Ioa_ReadGetLine(p, pCur), pCur );
-        }
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Parses interfaces of the models.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Ioa_ReadReadInterfaces( Ioa_ReadMan_t * p )
-{
-    Ioa_ReadMod_t * pMod;
-    char * pLine;
-    int i, k;
-    // iterate through the models
-    Vec_PtrForEachEntry( p->vModels, pMod, i )
-    {
-        // parse the model
-        if ( !Ioa_ReadParseLineModel( pMod, pMod->pFirst ) )
-            return 0;
-        // parse the inputs
-        Vec_PtrForEachEntry( pMod->vInputs, pLine, k )
-            if ( !Ioa_ReadParseLineInputs( pMod, pLine ) )
-                return 0;
-        // parse the outputs
-        Vec_PtrForEachEntry( pMod->vOutputs, pLine, k )
-            if ( !Ioa_ReadParseLineOutputs( pMod, pLine ) )
-                return 0;
-        // parse the delay info
-        Vec_PtrForEachEntry( pMod->vDelays, pLine, k )
-            if ( !Ioa_ReadParseLineDelay( pMod, pLine ) )
-                return 0;
-        Vec_PtrForEachEntry( pMod->vArrivals, pLine, k )
-            if ( !Ioa_ReadParseLineTimes( pMod, pLine, 0 ) )
-                return 0;
-        Vec_PtrForEachEntry( pMod->vRequireds, pLine, k )
-            if ( !Ioa_ReadParseLineTimes( pMod, pLine, 1 ) )
-                return 0;
-    }
-    return 1;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static Ntl_Man_t * Ioa_ReadParse( Ioa_ReadMan_t * p )
-{
-    Ntl_Man_t * pDesign;
-    Ioa_ReadMod_t * pMod;
-    char * pLine;
-    int i, k;
-    // iterate through the models
-    Vec_PtrForEachEntry( p->vModels, pMod, i )
-    {
-        // parse the latches
-        Vec_PtrForEachEntry( pMod->vLatches, pLine, k )
-            if ( !Ioa_ReadParseLineLatch( pMod, pLine ) )
-                return NULL;
-        // parse the nodes
-        Vec_PtrForEachEntry( pMod->vNames, pLine, k )
-            if ( !Ioa_ReadParseLineNamesBlif( pMod, pLine ) )
-                return NULL;
-        // parse the subcircuits
-        Vec_PtrForEachEntry( pMod->vSubckts, pLine, k )
-            if ( !Ioa_ReadParseLineSubckt( pMod, pLine ) )
-                return NULL;
-        // finalize the network
-        Ntl_ModelFixNonDrivenNets( pMod->pNtk );
-    }
-    // return the network
-    pDesign = p->pDesign;
-    p->pDesign = NULL;
-    return pDesign;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Parses the model line.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Ioa_ReadParseLineModel( Ioa_ReadMod_t * p, char * pLine )
-{
-    Vec_Ptr_t * vTokens = p->pMan->vTokens;
-    char * pToken;
-    Ioa_ReadSplitIntoTokens( vTokens, pLine, '\0' );
-    pToken = Vec_PtrEntry( vTokens, 0 );
-    assert( !strcmp(pToken, "model") );
-    if ( Vec_PtrSize(vTokens) != 2 )
-    {
-        sprintf( p->pMan->sError, "Line %d: The number of entries in .model line (%d) is different from two.", Ioa_ReadGetLine(p->pMan, pToken), Vec_PtrSize(vTokens) );
-        return 0;
-    }
-    p->pNtk = Ntl_ModelAlloc( p->pMan->pDesign, Vec_PtrEntry(vTokens, 1) );
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Parses the inputs line.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Ioa_ReadParseLineInputs( Ioa_ReadMod_t * p, char * pLine )
-{
-    Ntl_Net_t * pNet;
-    Ntl_Obj_t * pObj;
-    Vec_Ptr_t * vTokens = p->pMan->vTokens;
-    char * pToken;
-    int i;
-    Ioa_ReadSplitIntoTokens( vTokens, pLine, '\0' );
-    pToken = Vec_PtrEntry(vTokens, 0);
-    assert( !strcmp(pToken, "inputs") );
-    Vec_PtrForEachEntryStart( vTokens, pToken, i, 1 )
-    {
-        pObj = Ntl_ModelCreatePi( p->pNtk );
-        pNet = Ntl_ModelFindOrCreateNet( p->pNtk, pToken );
-        if ( !Ntl_ModelSetNetDriver( pObj, pNet ) )
-        {
-            sprintf( p->pMan->sError, "Line %d: Net %s already has a driver.", Ioa_ReadGetLine(p->pMan, pToken), pNet->pName );
-            return 0;
-        }
-    }
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Parses the outputs line.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Ioa_ReadParseLineOutputs( Ioa_ReadMod_t * p, char * pLine )
-{
-    Ntl_Net_t * pNet;
-    Ntl_Obj_t * pObj;
-    Vec_Ptr_t * vTokens = p->pMan->vTokens;
-    char * pToken;
-    int i;
-    Ioa_ReadSplitIntoTokens( vTokens, pLine, '\0' );
-    pToken = Vec_PtrEntry(vTokens, 0);
-    assert( !strcmp(pToken, "outputs") );
-    Vec_PtrForEachEntryStart( vTokens, pToken, i, 1 )
-    {
-        pNet = Ntl_ModelFindOrCreateNet( p->pNtk, pToken );
-        pObj = Ntl_ModelCreatePo( p->pNtk, pNet );
-    }
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Parses the latches line.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Ioa_ReadParseLineLatch( Ioa_ReadMod_t * p, char * pLine )
-{
-    Vec_Ptr_t * vTokens = p->pMan->vTokens;
-    Ntl_Net_t * pNetLi, * pNetLo;
-    Ntl_Obj_t * pObj;
-    char * pToken, * pNameLi, * pNameLo;
-    int Init, Class;
-    Ioa_ReadSplitIntoTokens( vTokens, pLine, '\0' );
-    pToken = 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.", Ioa_ReadGetLine(p->pMan, pToken) );
-        return 0;
-    }
-    // create latch
-    pNameLi = Vec_PtrEntry( vTokens, 1 );
-    pNameLo = Vec_PtrEntry( vTokens, 2 );
-    pNetLi  = Ntl_ModelFindOrCreateNet( p->pNtk, pNameLi );
-    pNetLo  = Ntl_ModelFindOrCreateNet( p->pNtk, pNameLo );
-    pObj    = Ntl_ModelCreateLatch( p->pNtk );
-    pObj->pFanio[0] = pNetLi;
-    if ( !Ntl_ModelSetNetDriver( pObj, pNetLo ) )
-    {
-        sprintf( p->pMan->sError, "Line %d: Net %s already has a driver.", Ioa_ReadGetLine(p->pMan, pToken), pNetLo->pName );
-        return 0;
-    }
-    // get initial value
-    if ( Vec_PtrSize(vTokens) > 3 )
-        Init = atoi( Vec_PtrEntry(vTokens,Vec_PtrSize(vTokens)-1) );
-    else
-        Init = 2;
-    if ( Init < 0 || Init > 2 )
-    {
-        sprintf( p->pMan->sError, "Line %d: Initial state of the latch is incorrect \"%s\".", Ioa_ReadGetLine(p->pMan, pToken), Vec_PtrEntry(vTokens,3) );
-        return 0;
-    }
-    // get the register class
-    if ( Vec_PtrSize(vTokens) == 6 )
-        Class = atoi( Vec_PtrEntry(vTokens,3) );
-    else
-        Class = 0;
-    if ( Class < 0 || Class > (1<<24) )
-    {
-        sprintf( p->pMan->sError, "Line %d: Class of the latch is incorrect \"%s\".", Ioa_ReadGetLine(p->pMan, pToken), Vec_PtrEntry(vTokens,4) );
-        return 0;
-    }
-    pObj->LatchId = (Class << 2) | Init;
-    // get the clock
-    if ( Vec_PtrSize(vTokens) == 5 || Vec_PtrSize(vTokens) == 6 )
-    {
-        pToken = Vec_PtrEntry(vTokens,Vec_PtrSize(vTokens)-2);
-        pNetLi = Ntl_ModelFindOrCreateNet( p->pNtk, pToken );
-        pObj->pFanio[1] = pNetLi;
-    }
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Parses the subckt line.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Ioa_ReadParseLineSubckt( Ioa_ReadMod_t * p, char * pLine )
-{
-    Vec_Ptr_t * vTokens = p->pMan->vTokens;
-    Ntl_Mod_t * pModel;
-    Ntl_Obj_t * pBox, * pTerm;
-    Ntl_Net_t * pNet;
-    char * pToken, * pName, ** ppNames;
-    int nEquals, i, k;
-
-    // split the line into tokens
-    nEquals = Ioa_ReadCountChars( pLine, '=' );
-    Ioa_ReadSplitIntoTokensAndClear( vTokens, pLine, '\0', '=' );
-    pToken = Vec_PtrEntry(vTokens,0);
-    assert( !strcmp(pToken, "subckt") );
-
-    // get the model for this box
-    pName = Vec_PtrEntry(vTokens,1);
-    pModel = Ntl_ManFindModel( p->pMan->pDesign, pName );
-    if ( pModel == NULL )
-    {
-        sprintf( p->pMan->sError, "Line %d: Cannot find the model for subcircuit %s.", Ioa_ReadGetLine(p->pMan, pToken), pName );
-        return 0;
-    }
-
-    // check if the number of tokens is correct
-    if ( nEquals != Ntl_ModelPiNum(pModel) + Ntl_ModelPoNum(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).", 
-            Ioa_ReadGetLine(p->pMan, pToken), nEquals, Ntl_ModelPiNum(pModel) + Ntl_ModelPoNum(pModel) );
-        return 0;
-    }
-
-    // get the names
-    ppNames = (char **)Vec_PtrArray(vTokens) + 2;
-
-    // create the box with these terminals
-    pBox = Ntl_ModelCreateBox( p->pNtk, Ntl_ModelPiNum(pModel), Ntl_ModelPoNum(pModel) );
-    pBox->pImplem = pModel;
-    Ntl_ModelForEachPi( pModel, pTerm, i )
-    {
-        // find this terminal among the formal inputs of the subcircuit
-        pName = Ntl_ObjFanout0(pTerm)->pName;
-        for ( k = 0; k < nEquals; k++ )
-            if ( !strcmp( ppNames[2*k], pName ) )
-                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.", 
-                Ioa_ReadGetLine(p->pMan, pToken), pName, pModel->pName );
-            return 0;
-        }
-        // create the BI with the actual name
-        pNet = Ntl_ModelFindOrCreateNet( p->pNtk, ppNames[2*k+1] );
-        Ntl_ObjSetFanin( pBox, pNet, i );
-    }
-    Ntl_ModelForEachPo( pModel, pTerm, i )
-    {
-        // find this terminal among the formal outputs of the subcircuit
-        pName = Ntl_ObjFanin0(pTerm)->pName;
-        for ( k = 0; k < nEquals; k++ )
-            if ( !strcmp( ppNames[2*k], pName ) )
-                break;
-        if ( k == nEquals )
-        {
-            sprintf( p->pMan->sError, "Line %d: Cannot find PO \"%s\" of the model \"%s\" as a formal output of the subcircuit.", 
-                Ioa_ReadGetLine(p->pMan, pToken), pName, pModel->pName );
-            return 0;
-        }
-        // create the BI with the actual name
-        pNet = Ntl_ModelFindOrCreateNet( p->pNtk, ppNames[2*k+1] );
-        Ntl_ObjSetFanout( pBox, pNet, i );
-    }
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Parses the subckt line.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Ioa_ReadParseLineDelay( Ioa_ReadMod_t * p, char * pLine )
-{
-    Vec_Ptr_t * vTokens = p->pMan->vTokens;
-    int RetValue1, RetValue2, Number1, Number2, Temp;
-    char * pToken, * pTokenNum;
-    float Delay;
-    assert( sizeof(float) == sizeof(int) );
-    Ioa_ReadSplitIntoTokens( vTokens, pLine, '\0' );
-    pToken = Vec_PtrEntry(vTokens,0);
-    assert( !strcmp(pToken, "delay") );
-    if ( Vec_PtrSize(vTokens) < 2 && Vec_PtrSize(vTokens) > 4 )
-    {
-        sprintf( p->pMan->sError, "Line %d: Delay line does not have a valid number of parameters (1, 2, or 3).", Ioa_ReadGetLine(p->pMan, pToken) );
-        return 0;
-    }
-    // find the delay number
-    pTokenNum = Vec_PtrEntryLast(vTokens);
-    Delay = atof( pTokenNum );
-    if ( Delay == 0.0 && pTokenNum[0] != '0' )
-    {
-        sprintf( p->pMan->sError, "Line %d: Delay value (%s) appears to be invalid.", Ioa_ReadGetLine(p->pMan, pToken), Vec_PtrEntryLast(vTokens) );
-        return 0;
-    }
-    // find the PI/PO numbers
-    RetValue1 = 0; Number1 = -1;
-    if ( Vec_PtrSize(vTokens) > 2 )
-    {
-        RetValue1 = Ntl_ModelFindPioNumber( p->pNtk, Vec_PtrEntry(vTokens, 1), &Number1 );
-        if ( RetValue1 == 0 )
-        {
-            sprintf( p->pMan->sError, "Line %d: Cannot find signal \"%s\" among PIs/POs.", Ioa_ReadGetLine(p->pMan, pToken), Vec_PtrEntry(vTokens, 1) );
-            return 0;
-        }
-    }
-    RetValue2 = 0; Number2 = -1;
-    if ( Vec_PtrSize(vTokens) > 3 )
-    {
-        RetValue2 = Ntl_ModelFindPioNumber( p->pNtk, Vec_PtrEntry(vTokens, 2), &Number2 );
-        if ( RetValue2 == 0 )
-        {
-            sprintf( p->pMan->sError, "Line %d: Cannot find signal \"%s\" among PIs/POs.", Ioa_ReadGetLine(p->pMan, pToken), Vec_PtrEntry(vTokens, 2) );
-            return 0;
-        }
-    }
-    if ( RetValue1 == RetValue2 && RetValue1 )
-    {
-        sprintf( p->pMan->sError, "Line %d: Both signals \"%s\" and \"%s\" listed appear to be PIs or POs.", 
-            Ioa_ReadGetLine(p->pMan, pToken), Vec_PtrEntry(vTokens, 1), Vec_PtrEntry(vTokens, 2) );
-        return 0;
-    }
-    if ( RetValue2 < RetValue1 )
-    {
-        Temp = RetValue2; RetValue2 = RetValue1; RetValue1 = Temp;
-        Temp = Number2;   Number2 = Number1;     Number1 = Temp;
-    }
-    assert( RetValue1 == 0 || RetValue1 == -1 );
-    assert( RetValue2 == 0 || RetValue2 ==  1 );
-    // store the values
-    if ( p->pNtk->vDelays == NULL )
-        p->pNtk->vDelays = Vec_IntAlloc( 100 );
-    Vec_IntPush( p->pNtk->vDelays, Number1 );
-    Vec_IntPush( p->pNtk->vDelays, Number2 );
-    Vec_IntPush( p->pNtk->vDelays, Aig_Float2Int(Delay) );        
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Parses the subckt line.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static int Ioa_ReadParseLineTimes( Ioa_ReadMod_t * p, char * pLine, int fOutput )
-{
-    Vec_Ptr_t * vTokens = p->pMan->vTokens;
-    int RetValue, Number;
-    char * pToken, * pTokenNum;
-    float Delay;
-    assert( sizeof(float) == sizeof(int) );
-    Ioa_ReadSplitIntoTokens( vTokens, pLine, '\0' );
-    pToken = Vec_PtrEntry(vTokens,0);
-    if ( fOutput )
-        assert( !strcmp(pToken, "output_required") );
-    else
-        assert( !strcmp(pToken, "input_arrival") );
-    if ( Vec_PtrSize(vTokens) != 3 )
-    {
-        sprintf( p->pMan->sError, "Line %d: Delay line does not have a valid number of parameters (3).", Ioa_ReadGetLine(p->pMan, pToken) );
-        return 0;
-    }
-    // find the delay number
-    pTokenNum = Vec_PtrEntryLast(vTokens);
-    if ( !strcmp( pTokenNum, "-inf" ) )
-        Delay = -AIG_INFINITY;
-    else if ( !strcmp( pTokenNum, "inf" ) ) 
-        Delay = AIG_INFINITY;
-    else
-        Delay = atof( pTokenNum );
-    if ( Delay == 0.0 && pTokenNum[0] != '0' )
-    {
-        sprintf( p->pMan->sError, "Line %d: Delay value (%s) appears to be invalid.", Ioa_ReadGetLine(p->pMan, pToken), Vec_PtrEntryLast(vTokens) );
-        return 0;
-    }
-    // find the PI/PO numbers
-    if ( fOutput )
-    {
-        RetValue = Ntl_ModelFindPioNumber( p->pNtk, Vec_PtrEntry(vTokens, 1), &Number );
-        if ( RetValue == 0 )
-        {
-            sprintf( p->pMan->sError, "Line %d: Cannot find signal \"%s\" among POs.", Ioa_ReadGetLine(p->pMan, pToken), Vec_PtrEntry(vTokens, 1) );
-            return 0;
-        }
-        // store the values
-        if ( p->pNtk->vRequireds == NULL )
-            p->pNtk->vRequireds = Vec_IntAlloc( 100 );
-        Vec_IntPush( p->pNtk->vRequireds, Number );
-        Vec_IntPush( p->pNtk->vRequireds, Aig_Float2Int(Delay) );        
-    }
-    else
-    {
-        RetValue = Ntl_ModelFindPioNumber( p->pNtk, Vec_PtrEntry(vTokens, 1), &Number );
-        if ( RetValue == 0 )
-        {
-            sprintf( p->pMan->sError, "Line %d: Cannot find signal \"%s\" among PIs.", Ioa_ReadGetLine(p->pMan, pToken), Vec_PtrEntry(vTokens, 1) );
-            return 0;
-        }
-        // store the values
-        if ( p->pNtk->vArrivals == NULL )
-            p->pNtk->vArrivals = Vec_IntAlloc( 100 );
-        Vec_IntPush( p->pNtk->vArrivals, Number );
-        Vec_IntPush( p->pNtk->vArrivals, Aig_Float2Int(Delay) );        
-    }
-    return 1;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Constructs the SOP cover from the file parsing info.]
-
-  Description []
-  
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static char * Ioa_ReadParseTableBlif( Ioa_ReadMod_t * p, char * pTable, int nFanins )
-{
-    Vec_Ptr_t * vTokens = p->pMan->vTokens;
-    Vec_Str_t * vFunc = p->pMan->vFunc;
-    char * pProduct, * pOutput;
-    int i, Polarity = -1;
-
-    p->pMan->nTablesRead++;
-    // get the tokens
-    Ioa_ReadSplitIntoTokens( vTokens, pTable, '.' );
-    if ( Vec_PtrSize(vTokens) == 0 )
-        return Ntl_ManStoreSop( p->pMan->pDesign, " 0\n" );
-    if ( Vec_PtrSize(vTokens) == 1 )
-    {
-        pOutput = Vec_PtrEntry( vTokens, 0 );
-        if ( ((pOutput[0] - '0') & 0x8E) || pOutput[1] )
-        {
-            sprintf( p->pMan->sError, "Line %d: Constant table has wrong output value \"%s\".", Ioa_ReadGetLine(p->pMan, pOutput), pOutput );
-            return NULL;
-        }
-        return Ntl_ManStoreSop( p->pMan->pDesign, (pOutput[0] == '0') ? " 0\n" : " 1\n" );
-    }
-    pProduct = Vec_PtrEntry( vTokens, 0 );
-    if ( Vec_PtrSize(vTokens) % 2 == 1 )
-    {
-        sprintf( p->pMan->sError, "Line %d: Table has odd number of tokens (%d).", Ioa_ReadGetLine(p->pMan, pProduct), Vec_PtrSize(vTokens) );
-        return NULL;
-    }
-    // parse the table
-    Vec_StrClear( vFunc );
-    for ( i = 0; i < Vec_PtrSize(vTokens)/2; i++ )
-    {
-        pProduct = Vec_PtrEntry( vTokens, 2*i + 0 );
-        pOutput  = 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).", Ioa_ReadGetLine(p->pMan, pProduct), pProduct, nFanins );
-            return NULL;
-        }
-        if ( ((pOutput[0] - '0') & 0x8E) || pOutput[1] )
-        {
-            sprintf( p->pMan->sError, "Line %d: Output value \"%s\" is incorrect.", Ioa_ReadGetLine(p->pMan, pProduct), pOutput );
-            return NULL;
-        }
-        if ( Polarity == -1 )
-            Polarity = pOutput[0] - '0';
-        else if ( Polarity != pOutput[0] - '0' )
-        {
-            sprintf( p->pMan->sError, "Line %d: Output value \"%s\" differs from the value in the first line of the table (%d).", Ioa_ReadGetLine(p->pMan, pProduct), pOutput, Polarity );
-            return NULL;
-        }
-        // parse one product 
-        Vec_StrAppend( 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 Ioa_ReadParseLineNamesBlif( Ioa_ReadMod_t * p, char * pLine )
-{
-    Vec_Ptr_t * vTokens = p->pMan->vTokens;
-    Ntl_Obj_t * pNode;
-    Ntl_Net_t * pNetOut, * pNetIn;
-    char * pNameOut, * pNameIn;
-    int i;
-    Ioa_ReadSplitIntoTokens( vTokens, pLine, '\0' );
-    // parse the mapped node
-//    if ( !strcmp(Vec_PtrEntry(vTokens,0), "gate") )
-//        return Ioa_ReadParseLineGateBlif( p, vTokens );
-    // parse the regular name line
-    assert( !strcmp(Vec_PtrEntry(vTokens,0), "names") );
-    pNameOut = Vec_PtrEntryLast( vTokens );
-/*
-    if ( strcmp( pNameOut, "18434" ) == 0 )
-    {
-        int x = 0;
-    }
-*/
-    pNetOut = Ntl_ModelFindOrCreateNet( p->pNtk, pNameOut );
-    // create fanins
-    pNode = Ntl_ModelCreateNode( p->pNtk, Vec_PtrSize(vTokens) - 2 );
-    for ( i = 0; i < Vec_PtrSize(vTokens) - 2; i++ )
-    {
-        pNameIn = Vec_PtrEntry(vTokens, i+1);
-        pNetIn = Ntl_ModelFindOrCreateNet( p->pNtk, pNameIn );
-        Ntl_ObjSetFanin( pNode, pNetIn, i );
-    }
-    if ( !Ntl_ModelSetNetDriver( pNode, pNetOut ) )
-    {
-        sprintf( p->pMan->sError, "Line %d: Signal \"%s\" is defined more than once.", Ioa_ReadGetLine(p->pMan, pNameOut), pNameOut );
-        return 0;
-    }
-    // parse the table of this node
-    pNode->pSop = Ioa_ReadParseTableBlif( p, pNameOut + strlen(pNameOut), pNode->nFanins );
-    if ( pNode->pSop == NULL )
-        return 0;
-    pNode->pSop = Ntl_ManStoreSop( p->pNtk->pMan, pNode->pSop );
-    return 1;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-