From 3dfa92f288e41982d8243c4d103f28bd4ff440d9 Mon Sep 17 00:00:00 2001 From: Alan Mishchenko Date: Tue, 30 Oct 2012 22:28:48 -0700 Subject: Improvements to the truth table computations. --- src/opt/dau/dauCanon.c | 536 ++++++++++++++++++++++++++++++++++++++++++++++++ src/opt/dau/module.make | 1 + 2 files changed, 537 insertions(+) create mode 100644 src/opt/dau/dauCanon.c (limited to 'src/opt/dau') diff --git a/src/opt/dau/dauCanon.c b/src/opt/dau/dauCanon.c new file mode 100644 index 00000000..5603d4ca --- /dev/null +++ b/src/opt/dau/dauCanon.c @@ -0,0 +1,536 @@ +/**CFile**************************************************************** + + FileName [dauCanon.c] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [DAG-aware unmapping.] + + Synopsis [Canonical form computation.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: dauCanon.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#include "dauInt.h" +#include "misc/util/utilTruth.h" + +ABC_NAMESPACE_IMPL_START + +//////////////////////////////////////////////////////////////////////// +/// DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [Generate reverse bytes.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Abc_TtReverseBypes() +{ + int i, k; + for ( i = 0; i < 256; i++ ) + { + int Mask = 0; + for ( k = 0; k < 8; k++ ) + if ( (i >> k) & 1 ) + Mask |= (1 << (7-k)); +// printf( "%3d %3d\n", i, Mask ); + + if ( i % 16 == 0 ) + printf( "\n" ); + printf( "%-3d, ", Mask ); + } +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Abc_TtConfactorTest7( word * pTruth, int nVars, int N ) +{ + word Cof[4][1024]; + int i, nWords = Abc_TtWordNum( nVars ); + int Counter = 0; + for ( i = 0; i < nVars-1; i++ ) + { + Abc_TtCopy( Cof[0], pTruth, nWords, 0 ); + Abc_TtCofactor0( Cof[0], nWords, i ); + Abc_TtCofactor0( Cof[0], nWords, i + 1 ); + + Abc_TtCopy( Cof[1], pTruth, nWords, 0 ); + Abc_TtCofactor1( Cof[1], nWords, i ); + Abc_TtCofactor0( Cof[1], nWords, i + 1 ); + + Abc_TtCopy( Cof[2], pTruth, nWords, 0 ); + Abc_TtCofactor0( Cof[2], nWords, i ); + Abc_TtCofactor1( Cof[2], nWords, i + 1 ); + + Abc_TtCopy( Cof[3], pTruth, nWords, 0 ); + Abc_TtCofactor1( Cof[3], nWords, i ); + Abc_TtCofactor1( Cof[3], nWords, i + 1 ); + + if ( i == 5 && N == 4 ) + { + printf( "\n" ); + Abc_TtPrintHex( Cof[0], nVars ); + Abc_TtPrintHex( Cof[1], nVars ); + Abc_TtPrintHex( Cof[2], nVars ); + Abc_TtPrintHex( Cof[3], nVars ); + } + + assert( Abc_TtCompareRev(Cof[0], Cof[1], nWords) == Abc_TtCompare2VarCofsRev(pTruth, nWords, i, 0, 1) ); + assert( Abc_TtCompareRev(Cof[0], Cof[2], nWords) == Abc_TtCompare2VarCofsRev(pTruth, nWords, i, 0, 2) ); + assert( Abc_TtCompareRev(Cof[0], Cof[3], nWords) == Abc_TtCompare2VarCofsRev(pTruth, nWords, i, 0, 3) ); + assert( Abc_TtCompareRev(Cof[1], Cof[2], nWords) == Abc_TtCompare2VarCofsRev(pTruth, nWords, i, 1, 2) ); + assert( Abc_TtCompareRev(Cof[1], Cof[3], nWords) == Abc_TtCompare2VarCofsRev(pTruth, nWords, i, 1, 3) ); + assert( Abc_TtCompareRev(Cof[2], Cof[3], nWords) == Abc_TtCompare2VarCofsRev(pTruth, nWords, i, 2, 3) ); +/* + Counter += Abc_TtCompare(Cof[0], Cof[1], nWords); + Counter += Abc_TtCompare(Cof[0], Cof[2], nWords); + Counter += Abc_TtCompare(Cof[0], Cof[3], nWords); + Counter += Abc_TtCompare(Cof[1], Cof[2], nWords); + Counter += Abc_TtCompare(Cof[1], Cof[3], nWords); + Counter += Abc_TtCompare(Cof[2], Cof[3], nWords); + + Counter += Abc_TtCompare2VarCofs(pTruth, nWords, i, 0, 1); + Counter += Abc_TtCompare2VarCofs(pTruth, nWords, i, 0, 2); + Counter += Abc_TtCompare2VarCofs(pTruth, nWords, i, 0, 3); + Counter += Abc_TtCompare2VarCofs(pTruth, nWords, i, 1, 2); + Counter += Abc_TtCompare2VarCofs(pTruth, nWords, i, 1, 3); + Counter += Abc_TtCompare2VarCofs(pTruth, nWords, i, 2, 3); +*/ + } +} +void Abc_TtConfactorTest2( word * pTruth, int nVars, int N ) +{ +// word Cof[4][1024]; + int i, j, nWords = Abc_TtWordNum( nVars ); + int Counter = 0; + for ( i = 0; i < nVars-1; i++ ) + for ( j = i+1; j < nVars; j++ ) + { +/* + Abc_TtCopy( Cof[0], pTruth, nWords, 0 ); + Abc_TtCofactor0( Cof[0], nWords, i ); + Abc_TtCofactor0( Cof[0], nWords, j ); + + Abc_TtCopy( Cof[1], pTruth, nWords, 0 ); + Abc_TtCofactor1( Cof[1], nWords, i ); + Abc_TtCofactor0( Cof[1], nWords, j ); + + Abc_TtCopy( Cof[2], pTruth, nWords, 0 ); + Abc_TtCofactor0( Cof[2], nWords, i ); + Abc_TtCofactor1( Cof[2], nWords, j ); + + Abc_TtCopy( Cof[3], pTruth, nWords, 0 ); + Abc_TtCofactor1( Cof[3], nWords, i ); + Abc_TtCofactor1( Cof[3], nWords, j ); +*/ +/* + if ( i == 0 && j == 1 && N == 0 ) + { + printf( "\n" ); + Abc_TtPrintHexSpecial( Cof[0], nVars ); printf( "\n" ); + Abc_TtPrintHexSpecial( Cof[1], nVars ); printf( "\n" ); + Abc_TtPrintHexSpecial( Cof[2], nVars ); printf( "\n" ); + Abc_TtPrintHexSpecial( Cof[3], nVars ); printf( "\n" ); + } +*/ +/* + assert( Abc_TtEqual(Cof[0], Cof[1], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 0, 1) ); + assert( Abc_TtEqual(Cof[0], Cof[2], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 0, 2) ); + assert( Abc_TtEqual(Cof[0], Cof[3], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 0, 3) ); + assert( Abc_TtEqual(Cof[1], Cof[2], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 1, 2) ); + assert( Abc_TtEqual(Cof[1], Cof[3], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 1, 3) ); + assert( Abc_TtEqual(Cof[2], Cof[3], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 2, 3) ); +*/ + + Counter += Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 0, 1); + Counter += Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 0, 2); + Counter += Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 0, 3); + Counter += Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 1, 2); + Counter += Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 1, 3); + Counter += Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 2, 3); +/* + Counter += Abc_TtEqual(Cof[0], Cof[1], nWords); + Counter += Abc_TtEqual(Cof[0], Cof[2], nWords); + Counter += Abc_TtEqual(Cof[0], Cof[3], nWords); + Counter += Abc_TtEqual(Cof[1], Cof[2], nWords); + Counter += Abc_TtEqual(Cof[1], Cof[3], nWords); + Counter += Abc_TtEqual(Cof[2], Cof[3], nWords); +*/ + } +} +void Abc_TtConfactorTest3( word * pTruth, int nVars, int N ) +{ + word Cof[4][1024]; + int i, j, nWords = Abc_TtWordNum( nVars ); + for ( i = 0; i < nVars-1; i++ ) + for ( j = i+1; j < nVars; j++ ) + { + Abc_TtCopy( Cof[0], pTruth, nWords, 0 ); + Abc_TtCofactor0( Cof[0], nWords, i ); + Abc_TtCofactor0( Cof[0], nWords, j ); + + Abc_TtCopy( Cof[1], pTruth, nWords, 0 ); + Abc_TtCofactor1( Cof[1], nWords, i ); + Abc_TtCofactor0( Cof[1], nWords, j ); + + Abc_TtCopy( Cof[2], pTruth, nWords, 0 ); + Abc_TtCofactor0( Cof[2], nWords, i ); + Abc_TtCofactor1( Cof[2], nWords, j ); + + Abc_TtCopy( Cof[3], pTruth, nWords, 0 ); + Abc_TtCofactor1( Cof[3], nWords, i ); + Abc_TtCofactor1( Cof[3], nWords, j ); + + assert( Abc_TtEqual(Cof[0], Cof[1], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 0, 1) ); + assert( Abc_TtEqual(Cof[0], Cof[2], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 0, 2) ); + assert( Abc_TtEqual(Cof[0], Cof[3], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 0, 3) ); + assert( Abc_TtEqual(Cof[1], Cof[2], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 1, 2) ); + assert( Abc_TtEqual(Cof[1], Cof[3], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 1, 3) ); + assert( Abc_TtEqual(Cof[2], Cof[3], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 2, 3) ); + } +} + +void Abc_TtConfactorTest4( word * pTruth, int nVars, int N ) +{ + word Cof[4][1024]; + int i, j, nWords = Abc_TtWordNum( nVars ); + int Counter = 0, Sum = 0; + for ( i = 0; i < nVars-1; i++ ) + for ( j = i+1; j < nVars; j++ ) + { + Abc_TtCopy( Cof[0], pTruth, nWords, 0 ); + Abc_TtCofactor0( Cof[0], nWords, i ); + Abc_TtCofactor0( Cof[0], nWords, j ); + + Abc_TtCopy( Cof[1], pTruth, nWords, 0 ); + Abc_TtCofactor1( Cof[1], nWords, i ); + Abc_TtCofactor0( Cof[1], nWords, j ); + + Abc_TtCopy( Cof[2], pTruth, nWords, 0 ); + Abc_TtCofactor0( Cof[2], nWords, i ); + Abc_TtCofactor1( Cof[2], nWords, j ); + + Abc_TtCopy( Cof[3], pTruth, nWords, 0 ); + Abc_TtCofactor1( Cof[3], nWords, i ); + Abc_TtCofactor1( Cof[3], nWords, j ); + + + Sum = 0; + Sum += Abc_TtEqual(Cof[0], Cof[1], nWords); + Sum += Abc_TtEqual(Cof[0], Cof[2], nWords); + Sum += Abc_TtEqual(Cof[0], Cof[3], nWords); + Sum += Abc_TtEqual(Cof[1], Cof[2], nWords); + Sum += Abc_TtEqual(Cof[1], Cof[3], nWords); + Sum += Abc_TtEqual(Cof[2], Cof[3], nWords); + + assert( Abc_TtEqual(Cof[0], Cof[1], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 0, 1) ); + assert( Abc_TtEqual(Cof[0], Cof[2], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 0, 2) ); + assert( Abc_TtEqual(Cof[0], Cof[3], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 0, 3) ); + assert( Abc_TtEqual(Cof[1], Cof[2], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 1, 2) ); + assert( Abc_TtEqual(Cof[1], Cof[3], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 1, 3) ); + assert( Abc_TtEqual(Cof[2], Cof[3], nWords) == Abc_TtCheckEqualCofs(pTruth, nWords, i, j, 2, 3) ); + } +} + +void Abc_TtConfactorTest6( word * pTruth, int nVars, int N ) +{ +// word Cof[4][1024]; + int i, nWords = Abc_TtWordNum( nVars ); +// if ( N != 30 ) +// return; + printf( "\n " ); + Abc_TtPrintHex( pTruth, nVars ); +// Kit_DsdPrintFromTruth( pTruth, nVars ); printf( "\n" ); + + for ( i = nVars - 1; i >= 0; i-- ) + { +/* + Abc_TtCopy( Cof[0], pTruth, nWords, 0 ); + Abc_TtCofactor0( Cof[0], nWords, i ); + printf( "- " ); + Abc_TtPrintHex( Cof[0], nVars ); + + Abc_TtCopy( Cof[1], pTruth, nWords, 0 ); + Abc_TtCofactor1( Cof[1], nWords, i ); + printf( "+ " ); + Abc_TtPrintHex( Cof[1], nVars ); +*/ + if ( Abc_TtCompare1VarCofsRev( pTruth, nWords, i ) == -1 ) + { + printf( "%d ", i ); + Abc_TtFlip( pTruth, nWords, i ); + Abc_TtPrintHex( pTruth, nVars ); +// Kit_DsdPrintFromTruth( pTruth, nVars ); printf( "\n" ); + } + + +/* + Abc_TtCopy( Cof[0], pTruth, nWords, 0 ); + Abc_TtCofactor0( Cof[0], nWords, i ); + + Abc_TtCopy( Cof[1], pTruth, nWords, 0 ); + Abc_TtCofactor1( Cof[1], nWords, i ); + + assert( Abc_TtCompareRev(Cof[0], Cof[1], nWords) == Abc_TtCompare1VarCofsRev(pTruth, nWords, i) ); +*/ + } + i = 0; +} + +int Abc_TtConfactorPermNaive( word * pTruth, int i, int nVars ) +{ + static word pCopy[1024]; + static word pBest[1024]; + + int nWords = Abc_TtWordNum( nVars ); + + // save two copies + Abc_TtCopy( pCopy, pTruth, nWords, 0 ); + Abc_TtCopy( pBest, pTruth, nWords, 0 ); + + // PXY + // 001 + Abc_TtFlip( pCopy, nWords, i ); + if ( Abc_TtCompareRev(pBest, pCopy, nWords) == 1 ) + Abc_TtCopy( pBest, pCopy, nWords, 0 ); + + // PXY + // 011 + Abc_TtFlip( pCopy, nWords, i+1 ); + if ( Abc_TtCompareRev(pBest, pCopy, nWords) == 1 ) + Abc_TtCopy( pBest, pCopy, nWords, 0 ); + + // PXY + // 010 + Abc_TtFlip( pCopy, nWords, i ); + if ( Abc_TtCompareRev(pBest, pCopy, nWords) == 1 ) + Abc_TtCopy( pBest, pCopy, nWords, 0 ); + + // PXY + // 110 + Abc_TtSwapVars( pCopy, nVars, i, i+1 ); + if ( Abc_TtCompareRev(pBest, pCopy, nWords) == 1 ) + Abc_TtCopy( pBest, pCopy, nWords, 0 ); + + // PXY + // 111 + Abc_TtFlip( pCopy, nWords, i+1 ); + if ( Abc_TtCompareRev(pBest, pCopy, nWords) == 1 ) + Abc_TtCopy( pBest, pCopy, nWords, 0 ); + + // PXY + // 101 + Abc_TtFlip( pCopy, nWords, i ); + if ( Abc_TtCompareRev(pBest, pCopy, nWords) == 1 ) + Abc_TtCopy( pBest, pCopy, nWords, 0 ); + + // PXY + // 100 + Abc_TtFlip( pCopy, nWords, i+1 ); + if ( Abc_TtCompareRev(pBest, pCopy, nWords) == 1 ) + Abc_TtCopy( pBest, pCopy, nWords, 0 ); + + // PXY + // 000 + Abc_TtSwapVars( pCopy, nVars, i, i+1 ); + if ( Abc_TtCompareRev(pBest, pCopy, nWords) == 1 ) + Abc_TtCopy( pBest, pCopy, nWords, 0 ); + + assert( Abc_TtEqual( pTruth, pCopy, nWords ) ); + if ( Abc_TtEqual( pTruth, pBest, nWords ) ) + return 0; + Abc_TtCopy( pTruth, pBest, nWords, 0 ); + return 1; +} + + +int Abc_TtConfactorPerm( word * pTruth, int i, int nVars ) +{ + int nWords = Abc_TtWordNum( nVars ); + int fComp01, fComp02, fComp03, fComp12, fComp13, fComp23; + int RetValue = 0; + fComp23 = Abc_TtCompare2VarCofsRev( pTruth, nWords, i, 2, 3 ); + fComp01 = Abc_TtCompare2VarCofsRev( pTruth, nWords, i, 0, 1 ); + if ( fComp23 >= 1 ) // Cof2 >= Cof3 + { + if ( fComp01 >= 1 ) // Cof0 >= Cof1 + { + fComp13 = Abc_TtCompare2VarCofsRev( pTruth, nWords, i, 1, 3 ); + if ( fComp13 < 1 ) // Cof1 < Cof3 ) + Abc_TtFlip( pTruth, nWords, i + 1 ), RetValue = 1; + } + else // Cof0 < Cof1 + { + fComp03 = Abc_TtCompare2VarCofsRev( pTruth, nWords, i, 0, 3 ); + if ( fComp03 < 1 ) // Cof0 < Cof3 ) + { + Abc_TtFlip( pTruth, nWords, i ); + Abc_TtFlip( pTruth, nWords, i + 1 ), RetValue = 1; + } + else // Cof0 >= Cof3 + { + if ( fComp23 == 0 ) + Abc_TtFlip( pTruth, nWords, i ), RetValue = 1; + } + } + } + else // Cof2 < Cof3 + { + if ( fComp01 >= 1 ) // Cof0 >= Cof1 + { + fComp12 = Abc_TtCompare2VarCofsRev( pTruth, nWords, i, 1, 2 ); + if ( fComp12 < 1 ) // Cof1 < Cof2 ) + Abc_TtFlip( pTruth, nWords, i + 1 ), RetValue = 1; + } + else // Cof0 < Cof1 + { + fComp02 = Abc_TtCompare2VarCofsRev( pTruth, nWords, i, 0, 2 ); + if ( fComp02 == -1 ) // Cof0 < Cof2 ) + Abc_TtFlip( pTruth, nWords, i + 1 ); + Abc_TtFlip( pTruth, nWords, i ), RetValue = 1; + } + } + + // perform final swap if needed + fComp12 = Abc_TtCompare2VarCofsRev( pTruth, nWords, i, 1, 2 ); + if ( fComp12 == 1 ) // Cof1 > Cof2 + Abc_TtSwapVars( pTruth, nVars, i, i+1 ), RetValue = 1; + return RetValue; +} + +void Abc_TtConfactorTest8( word * pTruth, int nVars, int N ) +{ + int fVerbose = 0; + int i; + + if ( fVerbose ) + printf( "\n " ), Abc_TtPrintHex( pTruth, nVars ); + + if ( fVerbose ) + printf( "Round 1\n" ); + for ( i = nVars - 2; i >= 0; i-- ) + { + if ( Abc_TtConfactorPermNaive( pTruth, i, nVars ) ) + { + if ( fVerbose ) + printf( "%d ", i ), Abc_TtPrintHex( pTruth, nVars ); + } + } + + if ( fVerbose ) + printf( "Round 2\n" ); + for ( i = 0; i < nVars - 1; i++ ) + { + if ( Abc_TtConfactorPermNaive( pTruth, i, nVars ) ) + { + if ( fVerbose ) + printf( "%d ", i ), Abc_TtPrintHex( pTruth, nVars ); + } + } + + return; + + if ( fVerbose ) + printf( "Round 3\n" ); + for ( i = nVars - 2; i >= 0; i-- ) + { + if ( Abc_TtConfactorPermNaive( pTruth, i, nVars ) ) + { + if ( fVerbose ) + printf( "%d ", i ), Abc_TtPrintHex( pTruth, nVars ); + } + } + + if ( fVerbose ) + printf( "Round 4\n" ); + for ( i = 0; i < nVars - 1; i++ ) + { + if ( Abc_TtConfactorPermNaive( pTruth, i, nVars ) ) + { + if ( fVerbose ) + printf( "%d ", i ), Abc_TtPrintHex( pTruth, nVars ); + } + } + i = 0; +} + +void Abc_TtConfactorTest10( word * pTruth, int nVars, int N ) +{ + static word pCopy1[1024]; + static word pCopy2[1024]; + int nWords = Abc_TtWordNum( nVars ); + int i; + + for ( i = 0; i < nVars - 1; i++ ) + { +// Kit_DsdPrintFromTruth( pTruth, nVars ); printf( "\n" ); + + Abc_TtCopy( pCopy1, pTruth, nWords, 0 ); + Abc_TtSwapAdjacent( pCopy1, nWords, i ); +// Kit_DsdPrintFromTruth( pCopy1, nVars ); printf( "\n" ); + + Abc_TtCopy( pCopy2, pTruth, nWords, 0 ); + Abc_TtSwapVars( pCopy2, nVars, i, i+1 ); +// Kit_DsdPrintFromTruth( pCopy2, nVars ); printf( "\n" ); + + assert( Abc_TtEqual( pCopy1, pCopy2, nWords ) ); + } +} + + +void Abc_TtConfactorTest( word * pTruth, int nVars, int N ) +{ + char pCanonPerm[32]; + static word pCopy1[1024]; + static word pCopy2[1024]; + int nWords = Abc_TtWordNum( nVars ); + +// Kit_DsdPrintFromTruth( pTruth, nVars ); printf( "\n" ); + +// Abc_TtCopy( pCopy1, pTruth, nWords, 0 ); +// Kit_TruthSemiCanonicize_Yasha( pCopy1, nVars, pCanonPerm ); +// Kit_DsdPrintFromTruth( pCopy1, nVars ); printf( "\n" ); + + Abc_TtCopy( pCopy2, pTruth, nWords, 0 ); + Abc_TtSemiCanonicize( pCopy2, nVars, pCanonPerm ); +// Kit_DsdPrintFromTruth( pCopy2, nVars ); printf( "\n" ); + +// assert( Abc_TtEqual( pCopy1, pCopy2, nWords ) ); +} + + + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + + +ABC_NAMESPACE_IMPL_END + diff --git a/src/opt/dau/module.make b/src/opt/dau/module.make index 87a800e9..854c0667 100644 --- a/src/opt/dau/module.make +++ b/src/opt/dau/module.make @@ -1,4 +1,5 @@ SRC += src/opt/dau/dau.c \ + src/opt/dau/dauCanon.c \ src/opt/dau/dauCore.c \ src/opt/dau/dauDsd.c \ src/opt/dau/dauEnum.c -- cgit v1.2.3