ioWritePla.c File Reference

#include "ioAbc.h"

Include dependency graph for ioWritePla.c:

Go to the source code of this file.

Functions
ABC_NAMESPACE_IMPL_START int	Io_WritePlaOne (FILE *pFile, Abc_Ntk_t *pNtk)
	DECLARATIONS ///.
int	Io_WritePla (Abc_Ntk_t *pNtk, char *pFileName)
int	Io_WriteMoPla (Abc_Ntk_t *pNtk, char *pFileName)
int	Io_WriteMoPlaM (Abc_Ntk_t *pNtk, char *pFileName, int nMints)

Function Documentation

Io_WriteMoPla()

int Io_WriteMoPla	(	Abc_Ntk_t *	pNtk,
		char *	pFileName )

Definition at line 576 of file ioWritePla.c.

{ return 1; }

Here is the caller graph for this function:

Io_WriteMoPlaM()

int Io_WriteMoPlaM	(	Abc_Ntk_t *	pNtk,
		char *	pFileName,
		int	nMints )

Definition at line 577 of file ioWritePla.c.

{ return 1; }

Io_WritePla()

int Io_WritePla	(	Abc_Ntk_t *	pNtk,
		char *	pFileName )

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

Synopsis [Writes the network in PLA format.]

Description []

SideEffects []

SeeAlso []

Definition at line 171 of file ioWritePla.c.

{
    Abc_Ntk_t * pExdc;
    FILE * pFile;
 
    assert( Abc_NtkIsSopNetlist(pNtk) );
    assert( Abc_NtkLevel(pNtk) == 1 );
 
    pFile = fopen( pFileName, "w" );
    if ( pFile == NULL )
    {
        fprintf( stdout, "Io_WritePla(): Cannot open the output file.\n" );
        return 0;
    }
    fprintf( pFile, "# Benchmark \"%s\" written by ABC on %s\n", pNtk->pName, Extra_TimeStamp() );
    // write the network
    Io_WritePlaOne( pFile, pNtk );
    // write EXDC network if it exists
    pExdc = Abc_NtkExdc( pNtk );
    if ( pExdc )
        printf( "Io_WritePla: EXDC is not written (warning).\n" );
    // finalize the file
    fclose( pFile );
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Io_WritePlaOne()

ABC_NAMESPACE_IMPL_START int Io_WritePlaOne	(	FILE *	pFile,
		Abc_Ntk_t *	pNtk )

DECLARATIONS ///.

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

FileName [ioWritePla.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Command processing package.]

Synopsis [Procedures to write the network in BENCH format.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

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

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

Synopsis [Writes the network in PLA format.]

Description []

SideEffects []

SeeAlso []

Definition at line 49 of file ioWritePla.c.

{
    ProgressBar * pProgress;
    Abc_Obj_t * pNode, * pFanin, * pDriver;
    char * pCubeIn, * pCubeOut, * pCube;
    int i, k, nProducts, nInputs, nOutputs, nFanins;
 
    nProducts = 0;
    Abc_NtkForEachCo( pNtk, pNode, i )
    {
        pDriver = Abc_ObjFanin0Ntk( Abc_ObjFanin0(pNode) );
        if ( !Abc_ObjIsNode(pDriver) )
        {
            nProducts++;
            continue;
        }
        if ( Abc_NodeIsConst(pDriver) )
        {
            if ( Abc_NodeIsConst1(pDriver) )
                nProducts++;
            continue;
        }
        nProducts += Abc_SopGetCubeNum((char *)pDriver->pData);
    }
 
    // collect the parameters
    nInputs  = Abc_NtkCiNum(pNtk);
    nOutputs = Abc_NtkCoNum(pNtk);
    pCubeIn  = ABC_ALLOC( char, nInputs + 1 );
    pCubeOut = ABC_ALLOC( char, nOutputs + 1 );
    memset( pCubeIn,  '-', (size_t)nInputs );     pCubeIn[nInputs]   = 0;
    memset( pCubeOut, '0', (size_t)nOutputs );    pCubeOut[nOutputs] = 0;
 
    // write the header
    fprintf( pFile, ".i %d\n", nInputs );
    fprintf( pFile, ".o %d\n", nOutputs );
    fprintf( pFile, ".ilb" );
    Abc_NtkForEachCi( pNtk, pNode, i )
        fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanout0(pNode)) );
    fprintf( pFile, "\n" );
    fprintf( pFile, ".ob" );
    Abc_NtkForEachCo( pNtk, pNode, i )
        fprintf( pFile, " %s", Abc_ObjName(Abc_ObjFanin0(pNode)) );
    fprintf( pFile, "\n" );
    fprintf( pFile, ".p %d\n", nProducts );
 
    // mark the CI nodes
    Abc_NtkForEachCi( pNtk, pNode, i )
        pNode->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)i;
 
    // write the cubes
    pProgress = Extra_ProgressBarStart( stdout, nOutputs );
    Abc_NtkForEachCo( pNtk, pNode, i )
    {
        // prepare the output cube
        if ( i - 1 >= 0 )
            pCubeOut[i-1] = '0';
        pCubeOut[i] = '1';
 
        // consider special cases of nodes
        pDriver = Abc_ObjFanin0Ntk( Abc_ObjFanin0(pNode) );
        if ( !Abc_ObjIsNode(pDriver) )
        {
            assert( Abc_ObjIsCi(pDriver) );
            pCubeIn[(int)(ABC_PTRUINT_T)pDriver->pCopy] = '1' - Abc_ObjFaninC0(pNode);
            fprintf( pFile, "%s %s\n", pCubeIn, pCubeOut );
            pCubeIn[(int)(ABC_PTRUINT_T)pDriver->pCopy] = '-';
            continue;
        }
        if ( Abc_NodeIsConst(pDriver) )
        {
            if ( Abc_NodeIsConst1(pDriver) )
                fprintf( pFile, "%s %s\n", pCubeIn, pCubeOut );
            continue;
        }
 
        // make sure the cover is not complemented
        assert( !Abc_SopIsComplement( (char *)pDriver->pData ) );
 
        // write the cubes
        nFanins = Abc_ObjFaninNum(pDriver);
        Abc_SopForEachCube( (char *)pDriver->pData, nFanins, pCube )
        {
            Abc_ObjForEachFanin( pDriver, pFanin, k )
            {
                pFanin = Abc_ObjFanin0Ntk(pFanin);
                assert( (int)(ABC_PTRUINT_T)pFanin->pCopy < nInputs );
                pCubeIn[(int)(ABC_PTRUINT_T)pFanin->pCopy] = pCube[k];
            }
            fprintf( pFile, "%s %s\n", pCubeIn, pCubeOut );
        }
        // clean the cube for future writing
        Abc_ObjForEachFanin( pDriver, pFanin, k )
        {
            pFanin = Abc_ObjFanin0Ntk(pFanin);
            assert( Abc_ObjIsCi(pFanin) );
            pCubeIn[(int)(ABC_PTRUINT_T)pFanin->pCopy] = '-';
        }
        Extra_ProgressBarUpdate( pProgress, i, NULL );
    }
    Extra_ProgressBarStop( pProgress );
    fprintf( pFile, ".e\n" );
 
    // clean the CI nodes
    Abc_NtkForEachCi( pNtk, pNode, i )
        pNode->pCopy = NULL;
    ABC_FREE( pCubeIn );
    ABC_FREE( pCubeOut );
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function: