/**Function*************************************************************
Synopsis [Converts SOP in ABC into SOP representation in Espresso.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
pset_family Abc_SopToEspresso( char * pSop )
{
char * pCube;
pset_family Cover;
pset set;
int nCubes, nVars, Value, v;
if ( pSop == NULL )
return NULL;
nVars = Abc_SopGetVarNum(pSop);
nCubes = Abc_SopGetCubeNum(pSop);
assert( cube.size == 2 * nVars );
if ( Abc_SopIsConst0(pSop) )
{
Cover = sf_new(0, cube.size);
return Cover;
}
if ( Abc_SopIsConst1(pSop) )
{
Cover = sf_new(1, cube.size);
set = GETSET(Cover, Cover->count++);
set_copy( set, cube.fullset );
return Cover;
}
// create the cover
Cover = sf_new(nCubes, cube.size);
// fill in the cubes
Abc_SopForEachCube( pSop, nVars, pCube )
{
set = GETSET(Cover, Cover->count++);
set_copy( set, cube.fullset );
Abc_CubeForEachVar( pCube, Value, v )
{
if ( Value == '0' )
set_remove(set, 2*v+1);
else if ( Value == '1' )
set_remove(set, 2*v);
}
}
pset_family expand_gasp(pset_family F, pset_family D, pset_family R, pset_family Foriginal)
{
int c1index;
pset_family G;
G = sf_new(10, cube.size);
for(c1index = 0; c1index < F->count; c1index++) {
expand1_gasp(F, D, R, Foriginal, c1index, &G);
}
G = sf_dupl(G);
G = expand(G, R, 0); return G;
}
pcover map_cover_to_unate(pset *T)
{
register unsigned int word_test, word_set, bit_test, bit_set;
register pcube p, pA;
pset_family A;
pcube *T1;
int ncol, i;
A = sf_new(CUBELISTSIZE(T), cdata.vars_unate);
A->count = CUBELISTSIZE(T);
foreachi_set(A, i, p) {
(void) set_clear(p, A->sf_size);
}
static pset_family reduce_gasp(pset_family F, pset_family D)
{
pset p, last, cunder, *FD;
pset_family G;
G = sf_new(F->count, cube.size);
FD = cube2list(F, D);
for( p=F->data, last= p+F->count*F->wsize; p< last; p+=F->wsize) {
cunder = reduce_cube(FD, p);
if (setp_empty(cunder)) {
fatal("empty reduction in reduce_gasp, shouldn't happen");
} else if (setp_equal(cunder, p)) {
(cunder[0] |= ( 0x8000)); G = sf_addset(G, p); } else {
(cunder[0] &= ~ ( 0x8000)); G = sf_addset(G, cunder);
}
if (debug & 0x0010) {
printf("REDUCE_GASP: %s reduced to %s\n", pc1(p), pc2(cunder));
}
((cunder) ? (free((char *) (cunder)), (cunder) = 0) : 0);
}
((FD[0]) ? (free((char *) (FD[0])), (FD[0]) = 0) : 0); ((FD) ? (free((char *) (FD)), (FD) = 0) : 0);;
return G;
}
static bool
compl_special_cases(set **T, set_family_t **Tbar)
{
set **T1, *p, *ceil, *cof=T[0];
set_family_t *A, *ceil_compl;
// Check for no cubes in the cover
if (T[2] == NULL) {
*Tbar = sf_addset(sf_new(1, CUBE.size), CUBE.fullset);
free_cubelist(T);
return TRUE;
}
// Check for only a single cube in the cover
if (T[3] == NULL) {
*Tbar = compl_cube(set_or(cof, cof, T[2]));
free_cubelist(T);
return TRUE;
}
// Check for a row of all 1's (implies complement is null)
for (T1 = T+2; (p = *T1++) != NULL; ) {
if (full_row(p, cof)) {
*Tbar = sf_new(0, CUBE.size);
free_cubelist(T);
return TRUE;
}
}
// Check for a column of all 0's which can be factored out
ceil = set_save(cof);
for (T1 = T+2; (p = *T1++) != NULL; ) {
set_or(ceil, ceil, p);
}
if (! setp_equal(ceil, CUBE.fullset)) {
ceil_compl = compl_cube(ceil);
set_or(cof, cof, set_diff(ceil, CUBE.fullset, ceil));
set_free(ceil);
*Tbar = sf_append(complement(T), ceil_compl);
return TRUE;
}
set_free(ceil);
// Collect column counts, determine unate variables, etc.
massive_count(T);
// If single active variable not factored out above, then tautology!
if (CDATA.vars_active == 1) {
*Tbar = sf_new(0, CUBE.size);
free_cubelist(T);
return TRUE;
// Check for unate cover
} else if (CDATA.vars_unate == CDATA.vars_active) {
A = map_cover_to_unate(T);
free_cubelist(T);
A = unate_compl(A);
*Tbar = map_unate_to_cover(A);
sf_free(A);
return TRUE;
// Not much we can do about it
} else {
return MAYBE;
}
}
