/**CFile****************************************************************
FileName [kitPla.c]
SystemName [ABC: Logic synthesis and verification system.]
PackageName [Computation kit.]
Synopsis [Manipulating SOP in the form of a C-string.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - Dec 6, 2006.]
Revision [$Id: kitPla.c,v 1.00 2006/12/06 00:00:00 alanmi Exp $]
***********************************************************************/
#include "kit.h"
#include "aig/aig/aig.h"
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Checks if the cover is constant 0.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Kit_PlaIsConst0( char * pSop )
{
return pSop[0] == ' ' && pSop[1] == '0';
}
/**Function*************************************************************
Synopsis [Checks if the cover is constant 1.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Kit_PlaIsConst1( char * pSop )
{
return pSop[0] == ' ' && pSop[1] == '1';
}
/**Function*************************************************************
Synopsis [Checks if the cover is a buffer.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Kit_PlaIsBuf( char * pSop )
{
if ( pSop[4] != 0 )
return 0;
if ( (pSop[0] == '1' && pSop[2] == '1') || (pSop[0] == '0' && pSop[2] == '0') )
return 1;
return 0;
}
/**Function*************************************************************
Synopsis [Checks if the cover is an inverter.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Kit_PlaIsInv( char * pSop )
{
if ( pSop[4] != 0 )
return 0;
if ( (pSop[0] == '0' && pSop[2] == '1') || (pSop[0] == '1' && pSop[2] == '0') )
return 1;
return 0;
}
/**Function*************************************************************
Synopsis [Reads the number of variables in the cover.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Kit_PlaGetVarNum( char * pSop )
{
char * pCur;
for ( pCur = pSop; *pCur != '\n'; pCur++ )
if ( *pCur == 0 )
return -1;
return pCur - pSop - 2;
}
/**Function*************************************************************
Synopsis [Reads the number of cubes in the cover.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Kit_PlaGetCubeNum( char * pSop )
{
char * pCur;
int nCubes = 0;
if ( pSop == NULL )
return 0;
for ( pCur = pSop; *pCur; pCur++ )
nCubes += (*pCur == '\n');
return nCubes;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Kit_PlaIsComplement( char * pSop )
{
char * pCur;
for ( pCur = pSop; *pCur; pCur++ )
if ( *pCur == '\n' )
return (int)(*(pCur - 1) == '0' || *(pCur - 1) == 'n');
assert( 0 );
return 0;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Kit_PlaComplement( char * pSop )
{
char * pCur;
for ( pCur = pSop; *pCur; pCur++ )
if ( *pCur == '\n' )
{
if ( *(pCur - 1) == '0' )
*(pCur - 1) = '1';
else if ( *(pCur - 1) == '1' )
*(pCur - 1) = '0';
else if ( *(pCur - 1) == 'x' )
*(pCur - 1) = 'n';
else if ( *(pCur - 1) == 'n' )
*(pCur - 1) = 'x';
else
assert( 0 );
}
}
/**Function*************************************************************
Synopsis [Creates the constant 1 cover with the given number of variables and cubes.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
char * Kit_PlaStart( void * p, int nCubes, int nVars )
{
Aig_MmFlex_t * pMan = (Aig_MmFlex_t *)p;
char * pSopCover, * pCube;
int i, Length;
Length = nCubes * (nVars + 3);
pSopCover = Aig_MmFlexEntryFetch( pMan, Length + 1 );
memset( pSopCover, '-', Length );
pSopCover[Length] = 0;
for ( i = 0; i < nCubes; i++ )
{
pCube = pSopCover + i * (nVars + 3);
pCube[nVars + 0] = ' ';
pCube[nVars + 1] = '1';
pCube[nVars + 2] = '\n';
}
return pSopCover;
}
/**Function*************************************************************
Synopsis [Creates the cover from the ISOP computed from TT.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
char * Kit_PlaCreateFromIsop( void * p, int nVars, Vec_Int_t * vCover )
{
Aig_MmFlex_t * pMan = (Aig_MmFlex_t *)p;
char * pSop, * pCube;
int i, k, Entry, Literal;
assert( Vec_IntSize(vCover) > 0 );
if ( Vec_IntSize(vCover) == 0 )
return NULL;
// start the cover
pSop = Kit_PlaStart( pMan, Vec_IntSize(vCover), nVars );
// create cubes
Vec_IntForEachEntry( vCover, Entry, i )
{
pCube = pSop + i * (nVars + 3);
for ( k = 0; k < nVars; k++ )
{
Literal = 3 & (Entry >> (k << 1));
if ( Literal == 1 )
pCube[k] = '0';
else if ( Literal == 2 )
pCube[k] = '1';
else if ( Literal != 0 )
assert( 0 );
}
}
return pSop;
}
/**Function*************************************************************
Synopsis [Creates the cover from the ISOP computed from TT.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Kit_PlaToIsop( char * pSop, Vec_Int_t * vCover )
{
char * pCube;
int k, nVars, Entry;
nVars = Kit_PlaGetVarNum( pSop );
assert( nVars > 0 );
// create cubes
Vec_IntClear( vCover );
for ( pCube = pSop; *pCube; pCube += nVars + 3 )
{
Entry = 0;
for ( k = nVars - 1; k >= 0; k-- )
if ( pCube[k] == '0' )
Entry = (Entry << 2) | 1;
else if ( pCube[k] == '1' )
Entry = (Entry << 2) | 2;
else if ( pCube[k] == '-' )
Entry = (Entry << 2);
else
assert( 0 );
Vec_IntPush( vCover, Entry );
}
}
/**Function*************************************************************
Synopsis [Allocates memory and copies the SOP into it.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
char * Kit_PlaStoreSop( void * p, char * pSop )
{
Aig_MmFlex_t * pMan = (Aig_MmFlex_t *)p;
char * pStore;
pStore = Aig_MmFlexEntryFetch( pMan, strlen(pSop) + 1 );
strcpy( pStore, pSop );
return pStore;
}
/**Function*************************************************************
Synopsis [Transforms truth table into the SOP.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
char * Kit_PlaFromTruth( void * p, unsigned * pTruth, int nVars, Vec_Int_t * vCover )
{
Aig_MmFlex_t * pMan = (Aig_MmFlex_t *)p;
char * pSop;
int RetValue;
if ( Kit_TruthIsConst0(pTruth, nVars) )
return Kit_PlaStoreSop( pMan, " 0\n" );
if ( Kit_TruthIsConst1(pTruth, nVars) )
return Kit_PlaStoreSop( pMan, " 1\n" );
RetValue = Kit_TruthIsop( pTruth, nVars, vCover, 0 ); // 1 );
assert( RetValue == 0 || RetValue == 1 );
pSop = Kit_PlaCreateFromIsop( pMan, nVars, vCover );
if ( RetValue )
Kit_PlaComplement( pSop );
return pSop;
}
/**Function*************************************************************
Synopsis [Creates the cover from the ISOP computed from TT.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
char * Kit_PlaFromIsop( Vec_Str_t * vStr, int nVars, Vec_Int_t * vCover )
{
int i, k, Entry, Literal;
assert( Vec_IntSize(vCover) > 0 );
if ( Vec_IntSize(vCover) == 0 )
return NULL;
Vec_StrClear( vStr );
Vec_IntForEachEntry( vCover, Entry, i )
{
for ( k = 0; k < nVars; k++ )
{
Literal = 3 & (Entry >> (k << 1));
if ( Literal == 1 )
Vec_StrPush( vStr, '0' );
else if ( Literal == 2 )
Vec_StrPush( vStr, '1' );
else if ( Literal == 0 )
Vec_StrPush( vStr, '-' );
else
assert( 0 );
}
Vec_StrPush( vStr, ' ' );
Vec_StrPush( vStr, '1' );
Vec_StrPush( vStr, '\n' );
}
Vec_StrPush( vStr, '\0' );
return Vec_StrArray( vStr );
}
/**Function*************************************************************
Synopsis [Creates the SOP from TT.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
char * Kit_PlaFromTruthNew( unsigned * pTruth, int nVars, Vec_Int_t * vCover, Vec_Str_t * vStr )
{
char * pResult;
// transform truth table into the SOP
int RetValue = Kit_TruthIsop( pTruth, nVars, vCover, 1 );
assert( RetValue == 0 || RetValue == 1 );
// check the case of constant cover
if ( Vec_IntSize(vCover) == 0 || (Vec_IntSize(vCover) == 1 && Vec_IntEntry(vCover,0) == 0) )
{
assert( RetValue == 0 );
Vec_StrClear( vStr );
Vec_StrAppend( vStr, (Vec_IntSize(vCover) == 0) ? " 0\n" : " 1\n" );
Vec_StrPush( vStr, '\0' );
return Vec_StrArray( vStr );
}
pResult = Kit_PlaFromIsop( vStr, nVars, vCover );
if ( RetValue )
Kit_PlaComplement( pResult );
if ( nVars < 6 )
assert( pTruth[0] == (unsigned)Kit_PlaToTruth6(pResult, nVars) );
else if ( nVars == 6 )
assert( *((ABC_UINT64_T*)pTruth) == Kit_PlaToTruth6(pResult, nVars) );
return pResult;
}
/**Function*************************************************************
Synopsis [Converts SOP into a truth table.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
ABC_UINT64_T Kit_PlaToTruth6( char * pSop, int nVars )
{
static ABC_UINT64_T Truth[8] = {
ABC_CONST(0xAAAAAAAAAAAAAAAA),
ABC_CONST(0xCCCCCCCCCCCCCCCC),
ABC_CONST(0xF0F0F0F0F0F0F0F0),
ABC_CONST(0xFF00FF00FF00FF00),
ABC_CONST(0xFFFF0000FFFF0000),
ABC_CONST(0xFFFFFFFF00000000),
ABC_CONST(0x0000000000000000),
ABC_CONST(0xFFFFFFFFFFFFFFFF)
};
ABC_UINT64_T valueAnd, valueOr = Truth[6];
int v, lit = 0;
assert( nVars < 7 );
do {
valueAnd = Truth[7];
for ( v = 0; v < nVars; v++, lit++ )
{
if ( pSop[lit] == '1' )
valueAnd &= Truth[v];
else if ( pSop[lit] == '0' )
valueAnd &= ~Truth[v];
else if ( pSop[lit] != '-' )
assert( 0 );
}
valueOr |= valueAnd;
assert( pSop[lit] == ' ' );
lit++;
lit++;
assert( pSop[lit] == '\n' );
lit++;
} while ( pSop[lit] );
if ( Kit_PlaIsComplement(pSop) )
valueOr = ~valueOr;
return valueOr;
}
/**Fnction*************************************************************
Synopsis [Converting SOP into a truth table.]
Description [The SOP is represented as a C-string, as documented in
file "bblif.h". The truth table is returned as a bit-string composed
of 2^nVars bits. For functions of less than 6 variables, the full
machine word is returned. (The truth table looks as if the function
had 5 variables.) The use of this procedure should be limited to
Boolean functions with no more than 16 inputs.]
SideEffects []
SeeAlso []
***********************************************************************/
void Kit_PlaToTruth( char * pSop, int nVars, Vec_Ptr_t * vVars, unsigned * pTemp, unsigned * pTruth )
{
int v, c, nCubes, fCompl = 0;
assert( pSop != NULL );
assert( nVars >= 0 );
if ( strlen(pSop) % (nVars + 3) != 0 )
{
printf( "Kit_PlaToTruth(): SOP is represented incorrectly.\n" );
return;
}
// iterate through the cubes
Kit_TruthClear( pTruth, nVars );
nCubes = strlen(pSop) / (nVars + 3);
for ( c = 0; c < nCubes; c++ )
{
fCompl = (pSop[nVars+1] == '0');
Kit_TruthFill( pTemp, nVars );
// iterate through the literals of the cube
for ( v = 0; v < nVars; v++ )
if ( pSop[v] == '1' )
Kit_TruthAnd( pTemp, pTemp, (unsigned *)Vec_PtrEntry(vVars, v), nVars );
else if ( pSop[v] == '0' )
Kit_TruthSharp( pTemp, pTemp, (unsigned *)Vec_PtrEntry(vVars, v), nVars );
// add cube to storage
Kit_TruthOr( pTruth, pTruth, pTemp, nVars );
// go to the next cube
pSop += (nVars + 3);
}
if ( fCompl )
Kit_TruthNot( pTruth, pTruth, nVars );
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_IMPL_END