cnfData.c File Reference

#include "cnf.h"

Include dependency graph for cnfData.c:

Go to the source code of this file.

Functions
void	Cnf_ReadMsops (char **ppSopSizes, char ***ppSops)
	FUNCTION DEFINITIONS ///.

Function Documentation

Cnf_ReadMsops()

void Cnf_ReadMsops	(	char **	ppSopSizes,
		char ***	ppSops )

FUNCTION DEFINITIONS ///.

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

Synopsis [Prepares the data for MSOPs of 4-variable functions.]

Description []

SideEffects []

SeeAlso []

Definition at line 4537 of file cnfData.c.

{
    unsigned uMasks[4][2] = {
        { 0x5555, 0xAAAA },
        { 0x3333, 0xCCCC },
        { 0x0F0F, 0xF0F0 },
        { 0x00FF, 0xFF00 }
    };
    char Map[256], * pPrev, * pMemory;
    char * pSopSizes, ** pSops;
    int i, k, b, Size;
 
    // map chars into their numbers
    for ( i = 0; i < 256; i++ )
        Map[i] = (char)(-1);
    for ( i = 0; i < 81; i++ )
        Map[(int)s_Data3[i]] = (char)i;
 
    // count the number of strings
    for ( Size = 0; s_Data4[Size] && Size < 100000; Size++ );
    assert( Size < 100000 );
 
    // allocate memory
    pMemory = ABC_ALLOC( char, Size * 75 );
    // copy the array into memory
    for ( i = 0; i < Size; i++ )
        for ( k = 0; k < 75; k++ )
            if ( s_Data4[i][k] == ' ' )
                pMemory[i*75+k] = (char)(-1);
            else
                pMemory[i*75+k] = Map[(int)s_Data4[i][k]];
 
    // set pointers and compute SOP sizes
    pSopSizes = ABC_ALLOC( char, 65536 );
    pSops = ABC_ALLOC( char *, 65536 );
    pSopSizes[0] = 0;
    pSops[0] = NULL;
    pPrev = pMemory;
    for ( k = 0, i = 1; i < 65536; k++ )
        if ( pMemory[k] == (char)(-1) )
        {
            pSopSizes[i] = pMemory + k - pPrev; 
            pSops[i++] = pPrev;
            pPrev = pMemory + k + 1;
        }
    *ppSopSizes = pSopSizes;
    *ppSops = pSops;
 
    // verify the results - derive truth table from SOP
    for ( i = 1; i < 65536; i++ )
    {
        int uTruth = 0, uCube, Lit;
        for ( k = 0; k < pSopSizes[i]; k++ )
        {
            uCube = 0xFFFF;
            Lit = pSops[i][k];
            for ( b = 3; b >= 0; b-- )
            {
                if ( Lit % 3 == 0 )
                    uCube &= uMasks[b][0];
                else if ( Lit % 3 == 1 )
                    uCube &= uMasks[b][1];
                Lit = Lit / 3;
            }
            uTruth |= uCube;
        }
        assert( uTruth == i );
    }
}

Here is the caller graph for this function: