ioReadBlifMv.c File Reference

#include "misc/zlib/zlib.h"
#include "misc/bzlib/bzlib.h"
#include "base/abc/abc.h"
#include "misc/vec/vecPtr.h"
#include "ioAbc.h"
#include "map/mio/mio.h"
#include "base/main/main.h"

Include dependency graph for ioReadBlifMv.c:

Go to the source code of this file.

Classes
struct	Io_MvVar_t_
struct	Io_MvMod_t_
struct	Io_MvMan_t_
struct	buflist

Macros
#define	IO_BLIFMV_MAXVALUES   256
	DECLARATIONS ///.

Typedefs
typedef struct Io_MvVar_t_	Io_MvVar_t
typedef struct Io_MvMod_t_	Io_MvMod_t
typedef struct Io_MvMan_t_	Io_MvMan_t
typedef struct buflist	buflist

Functions
void	Abc_NtkStartMvVars (Abc_Ntk_t *pNtk)
	DECLARATIONS ///.
Abc_Ntk_t *	Io_ReadBlifMv (char *pFileName, int fBlifMv, int fCheck)
	FUNCTION DEFINITIONS ///.
char *	Io_MvLoadFileBz2 (char *pFileName, long *pnFileSize)
void	Io_MvReplaceBuffersByShorts (char *p)

Variables
Vec_Ptr_t *	vGlobalLtlArray

Macro Definition Documentation

IO_BLIFMV_MAXVALUES

#define IO_BLIFMV_MAXVALUES   256

DECLARATIONS ///.

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

FileName [ioReadBlifMv.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Command processing package.]

Synopsis [Procedures to read BLIF-MV file.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - January 8, 2007.]

Revision [

Id

ioReadBlifMv.c,v 1.00 2007/01/08 00:00:00 alanmi Exp

]

Definition at line 33 of file ioReadBlifMv.c.

Typedef Documentation

buflist

typedef struct buflist buflist

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

Synopsis [Reads the file into a character buffer.]

Description []

SideEffects []

SeeAlso []

Io_MvMan_t

typedef struct Io_MvMan_t_ Io_MvMan_t

Definition at line 38 of file ioReadBlifMv.c.

Io_MvMod_t

typedef struct Io_MvMod_t_ Io_MvMod_t

Definition at line 37 of file ioReadBlifMv.c.

Io_MvVar_t

typedef struct Io_MvVar_t_ Io_MvVar_t

Definition at line 36 of file ioReadBlifMv.c.

Function Documentation

Abc_NtkStartMvVars()

void Abc_NtkStartMvVars ( Abc_Ntk_t * pNtk )

extern

DECLARATIONS ///.

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

FileName [abcBlifMv.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Procedures to process BLIF-MV networks and AIGs.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id

abcBlifMv.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Starts the Mv-Var manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 49 of file abcBlifMv.c.

{
    Vec_Att_t * pAttMan;
    assert( Abc_NtkMvVar(pNtk) == NULL );
    pAttMan = Vec_AttAlloc( Abc_NtkObjNumMax(pNtk) + 1, Mem_FlexStart(), (void(*)(void*))Mem_FlexStop, NULL, NULL );
    Vec_PtrWriteEntry( pNtk->vAttrs, VEC_ATTR_MVVAR, pAttMan );
//printf( "allocing attr\n" );
}

Here is the caller graph for this function:

Io_MvLoadFileBz2()

char * Io_MvLoadFileBz2	(	char *	pFileName,
		long *	pnFileSize )

Definition at line 551 of file ioReadBlifMv.c.

{
    FILE    * pFile;
    long       nFileSize = 0;
    char    * pContents;
    BZFILE  * b;
    int       bzError, RetValue;
    struct buflist * pNext;
    buflist * bufHead = NULL, * buf = NULL;
 
    pFile = fopen( pFileName, "rb" );
    if ( pFile == NULL )
    {
        Abc_Print( -1, "Io_MvLoadFileBz2(): The file is unavailable (absent or open).\n" );
        return NULL;
    }
    b = BZ2_bzReadOpen(&bzError,pFile,0,0,NULL,0);
    if (bzError != BZ_OK) {
        Abc_Print( -1, "Io_MvLoadFileBz2(): BZ2_bzReadOpen() failed with error %d.\n",bzError );
        return NULL;
    }
    do {
        if (!bufHead)
            buf = bufHead = ABC_ALLOC( buflist, 1 );
        else
            buf = buf->next = ABC_ALLOC( buflist, 1 );
        nFileSize += buf->nBuf = BZ2_bzRead(&bzError,b,buf->buf,1<<20);
        buf->next = NULL;
    } while (bzError == BZ_OK);
    if (bzError == BZ_STREAM_END) {
        // we're okay
        char * p;
        int nBytes = 0;
        BZ2_bzReadClose(&bzError,b);
        p = pContents = ABC_ALLOC( char, nFileSize + 10 );
        buf = bufHead;
        do {
            memcpy(p+nBytes,buf->buf,(size_t)buf->nBuf);
            nBytes += buf->nBuf;
//        } while((buf = buf->next));
            pNext = buf->next;
            ABC_FREE( buf );
        } while((buf = pNext));
    } else if (bzError == BZ_DATA_ERROR_MAGIC) {
        // not a BZIP2 file
        BZ2_bzReadClose(&bzError,b);
        fseek( pFile, 0, SEEK_END );
        nFileSize = ftell( pFile );
        if ( nFileSize == 0 )
        {
            Abc_Print( -1, "Io_MvLoadFileBz2(): The file is empty.\n" );
            return NULL;
        }
        pContents = ABC_ALLOC( char, nFileSize + 10 );
        rewind( pFile );
        RetValue = fread( pContents, nFileSize, 1, pFile );
    } else { 
        // Some other error.
        Abc_Print( -1, "Io_MvLoadFileBz2(): Unable to read the compressed BLIF.\n" );
        return NULL;
    }
    fclose( pFile );
    // finish off the file with the spare .end line
    // some benchmarks suddenly break off without this line
    strcpy( pContents + nFileSize, "\n.end\n" );
    *pnFileSize = nFileSize;
    return pContents;
}

Here is the call graph for this function:

Io_MvReplaceBuffersByShorts()

void Io_MvReplaceBuffersByShorts

(

char *

p

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 710 of file ioReadBlifMv.c.

{
    if ( !strstr(p, ".gate") )
        return;
    char * q, * pNext, * pShort = (char *)".short"; int i;
    for ( q = p; *q && (pNext = strstr(q, ".names")); q = pNext ) {
        for ( i = 0; i < 6; i++ )
            pNext[i] = pShort[i];
        while ( *pNext && *pNext++ != '\n' );
        if ( *pNext == 0 )
            return;
        while ( *pNext && *pNext != '\n' )
            *pNext++ = ' ';
        if ( *pNext == 0 )
            return;
    }
}

Here is the call graph for this function:

Io_ReadBlifMv()

Abc_Ntk_t * Io_ReadBlifMv	(	char *	pFileName,
		int	fBlifMv,
		int	fCheck )

FUNCTION DEFINITIONS ///.

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

Synopsis [Reads the network from the BLIF or BLIF-MV file.]

Description []

SideEffects []

SeeAlso []

Definition at line 142 of file ioReadBlifMv.c.

{
    FILE * pFile;
    Io_MvMan_t * p;
    Abc_Ntk_t * pNtk, * pExdc;
    Abc_Des_t * pDesign = NULL; 
    char * pDesignName;
    int RetValue, i;
    char * pLtlProp;
 
    // check that the file is available
    pFile = fopen( pFileName, "rb" );
    if ( pFile == NULL )
    {
        printf( "Io_ReadBlifMv(): The file is unavailable (absent or open).\n" );
        return 0;
    }
    fclose( pFile );
 
    // start the file reader
    p = Io_MvAlloc();
    p->fBlifMv   = fBlifMv;
    p->fUseReset = 1;
    p->pFileName = pFileName;
    p->pBuffer   = Io_MvLoadFile( pFileName );
    if ( p->pBuffer == NULL )
    {
        Io_MvFree( p );
        return NULL;
    }
    // set the design name
    pDesignName  = Extra_FileNameGeneric( pFileName );
    p->pDesign   = Abc_DesCreate( pDesignName );
    ABC_FREE( pDesignName );
    // free the HOP manager
    Hop_ManStop( (Hop_Man_t *)p->pDesign->pManFunc );
    p->pDesign->pManFunc = NULL;
    // prepare the file for parsing
    Io_MvReadPreparse( p );
    // parse interfaces of each network and construct the network
    if ( Io_MvReadInterfaces( p ) )
        pDesign = Io_MvParse( p );
    if ( p->sError[0] )
        fprintf( stdout, "%s\n", p->sError );
    Io_MvFree( p );
    if ( pDesign == NULL )
        return NULL;
// pDesign should be linked to all models of the design
 
    // make sure that everything is okay with the network structure
    if ( fCheck )
    {
        Vec_PtrForEachEntry( Abc_Ntk_t *, pDesign->vModules, pNtk, i )
        {
            if ( !Abc_NtkCheckRead( pNtk ) )
            {
                printf( "Io_ReadBlifMv: The network check has failed for model %s.\n", pNtk->pName );
                Abc_DesFree( pDesign, NULL );
                return NULL;
            }
        }
    }
 
//Abc_DesPrint( pDesign );
 
    // check if there is an EXDC network
    if ( Vec_PtrSize(pDesign->vModules) > 1 )
    {
        pNtk = (Abc_Ntk_t *)Vec_PtrEntry(pDesign->vModules, 0);
        Vec_PtrForEachEntryStart( Abc_Ntk_t *, pDesign->vModules, pExdc, i, 1 )
            if ( !strcmp(pExdc->pName, "EXDC") )
            {
                assert( pNtk->pExdc == NULL );
                pNtk->pExdc = pExdc;
                Vec_PtrRemove(pDesign->vModules, pExdc);
                pExdc->pDesign = NULL;
                i--;
            }
            else
                pNtk = pExdc;
    }
 
    // detect top-level model
    RetValue = Abc_DesFindTopLevelModels( pDesign );
    pNtk = (Abc_Ntk_t *)Vec_PtrEntry( pDesign->vTops, 0 );
    if ( RetValue > 1 )
        printf( "Warning: The design has %d root-level modules. The first one (%s) will be used.\n",
            Vec_PtrSize(pDesign->vTops), pNtk->pName );
 
    // extract the master network
    pNtk->pDesign = pDesign;
    pDesign->pManFunc = NULL;
 
    // verify the design for cyclic dependence
    assert( Vec_PtrSize(pDesign->vModules) > 0 );
    if ( Vec_PtrSize(pDesign->vModules) == 1 )
    {
//        printf( "Warning: The design is not hierarchical.\n" );
        Abc_DesFree( pDesign, pNtk );
        pNtk->pDesign = NULL;
        pNtk->pSpec = Extra_UtilStrsav( pFileName );
    }
    else
        Abc_NtkIsAcyclicHierarchy( pNtk );
 
//Io_WriteBlifMv( pNtk, "_temp_.mv" );
    if ( pNtk->pSpec == NULL )
        pNtk->pSpec = Extra_UtilStrsav( pFileName );
 
    vGlobalLtlArray = Vec_PtrAlloc( 100 );
    Vec_PtrForEachEntry( char *, vGlobalLtlArray, pLtlProp, i )
        Vec_PtrPush( pNtk->vLtlProperties, pLtlProp );
    Vec_PtrFreeP( &vGlobalLtlArray );
    return pNtk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

vGlobalLtlArray

Vec_Ptr_t* vGlobalLtlArray

Definition at line 40 of file ioReadBlifMv.c.