Version abc90215

13 files changed, 61 insertions, 61 deletions

diff --git a/src/opt/fxu/fxu.c b/src/opt/fxu/fxu.c
index b49ef9aa..9102d289 100644
--- a/src/opt/fxu/fxu.c
+++ b/src/opt/fxu/fxu.c
@@ -44,7 +44,7 @@ static int s_MemoryPeak;
   The entries corresponding to the PI and objects with trivial covers are NULL.
   The number of extracted covers (not exceeding p->nNodesExt) is returned. 
   Two other things are important for the correct operation of this procedure:
-  (1) The input covers do not have duplicated fanins and are SCC-free. 
+  (1) The input covers do not have duplicated fanins and are SCC-ABC_FREE. 
   (2) The fanins array contains the numbers of the fanin objects.]
                
   SideEffects []
@@ -225,7 +225,7 @@ char * Fxu_MemFetch( Fxu_Matrix * p, int nBytes )
     s_MemoryTotal += nBytes;
     if ( s_MemoryPeak < s_MemoryTotal )
         s_MemoryPeak = s_MemoryTotal;
-//    return malloc( nBytes );
+//    return ABC_ALLOC( char, nBytes );
     return Extra_MmFixedEntryFetch( p->pMemMan );
 }
 
@@ -243,7 +243,7 @@ char * Fxu_MemFetch( Fxu_Matrix * p, int nBytes )
 void Fxu_MemRecycle( Fxu_Matrix * p, char * pItem, int nBytes )
 {
     s_MemoryTotal -= nBytes;
-//    free( pItem );
+//    ABC_FREE( pItem );
     Extra_MmFixedEntryRecycle( p->pMemMan, pItem );
 }
 
diff --git a/src/opt/fxu/fxu.h b/src/opt/fxu/fxu.h
index e6d0b69e..b9a56b23 100644
--- a/src/opt/fxu/fxu.h
+++ b/src/opt/fxu/fxu.h
@@ -19,10 +19,6 @@
 #ifndef __FXU_H__
 #define __FXU_H__
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -33,6 +29,10 @@ extern "C" {
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 ////////////////////////////////////////////////////////////////////////
 ///                    STRUCTURE DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/opt/fxu/fxuCreate.c b/src/opt/fxu/fxuCreate.c
index 21dfd419..008cac46 100644
--- a/src/opt/fxu/fxuCreate.c
+++ b/src/opt/fxu/fxuCreate.c
@@ -98,13 +98,13 @@ Fxu_Matrix * Fxu_CreateMatrix( Fxu_Data_t * pData )
     // start the matrix
     p = Fxu_MatrixAllocate();
     // create the column labels 
-    p->ppVars = ALLOC( Fxu_Var *, 2 * (pData->nNodesOld + pData->nNodesExt) );
+    p->ppVars = ABC_ALLOC( Fxu_Var *, 2 * (pData->nNodesOld + pData->nNodesExt) );
     for ( i = 0; i < 2 * pData->nNodesOld; i++ )
         p->ppVars[i] = Fxu_MatrixAddVar( p );
 
     // allocate storage for all cube pairs at once
-    p->pppPairs = ALLOC( Fxu_Pair **, nCubesTotal + 100 );
-    p->ppPairs  = ALLOC( Fxu_Pair *,  nPairsStore + 100 );
+    p->pppPairs = ABC_ALLOC( Fxu_Pair **, nCubesTotal + 100 );
+    p->ppPairs  = ABC_ALLOC( Fxu_Pair *,  nPairsStore + 100 );
     memset( p->ppPairs, 0, sizeof(Fxu_Pair *) * nPairsStore );
     iCube = 0;
     iPair = 0;
@@ -133,7 +133,7 @@ Fxu_Matrix * Fxu_CreateMatrix( Fxu_Data_t * pData )
 
 
     // allocate room for the reordered literals
-    pOrder = ALLOC( int, nBitsMax );
+    pOrder = ABC_ALLOC( int, nBitsMax );
     // create the rows
     for ( i = 0; i < pData->nNodesOld; i++ )
     if ( (pSopCover = pData->vSops->pArray[i]) )
@@ -174,7 +174,7 @@ Fxu_Matrix * Fxu_CreateMatrix( Fxu_Data_t * pData )
                     Fxu_MatrixAddDivisor( p, pCube1, pCube2 );
         }
     }
-    FREE( pOrder );
+    ABC_FREE( pOrder );
 
     // consider the case when cube pairs should be preprocessed
     // before adding them to the set of divisors
diff --git a/src/opt/fxu/fxuHeapD.c b/src/opt/fxu/fxuHeapD.c
index c81ad818..9a8eb124 100644
--- a/src/opt/fxu/fxuHeapD.c
+++ b/src/opt/fxu/fxuHeapD.c
@@ -55,11 +55,11 @@ static void Fxu_HeapDoubleMoveDn( Fxu_HeapDouble * p, Fxu_Double * pDiv );
 Fxu_HeapDouble * Fxu_HeapDoubleStart()
 {
     Fxu_HeapDouble * p;
-    p = ALLOC( Fxu_HeapDouble, 1 );
+    p = ABC_ALLOC( Fxu_HeapDouble, 1 );
     memset( p, 0, sizeof(Fxu_HeapDouble) );
     p->nItems      = 0;
     p->nItemsAlloc = 10000;
-    p->pTree       = ALLOC( Fxu_Double *, p->nItemsAlloc + 1 );
+    p->pTree       = ABC_ALLOC( Fxu_Double *, p->nItemsAlloc + 1 );
     p->pTree[0]    = NULL;
     return p;
 }
@@ -79,7 +79,7 @@ Fxu_HeapDouble * Fxu_HeapDoubleStart()
 void Fxu_HeapDoubleResize( Fxu_HeapDouble * p )
 {
     p->nItemsAlloc *= 2;
-    p->pTree = REALLOC( Fxu_Double *, p->pTree, p->nItemsAlloc + 1 );
+    p->pTree = ABC_REALLOC( Fxu_Double *, p->pTree, p->nItemsAlloc + 1 );
 }
 
 /**Function*************************************************************
@@ -95,8 +95,8 @@ void Fxu_HeapDoubleResize( Fxu_HeapDouble * p )
 ***********************************************************************/
 void Fxu_HeapDoubleStop( Fxu_HeapDouble * p )
 {
-    free( p->pTree );
-    free( p );
+    ABC_FREE( p->pTree );
+    ABC_FREE( p );
 }
 
 
diff --git a/src/opt/fxu/fxuHeapS.c b/src/opt/fxu/fxuHeapS.c
index eaca8363..4a9bd3a4 100644
--- a/src/opt/fxu/fxuHeapS.c
+++ b/src/opt/fxu/fxuHeapS.c
@@ -55,11 +55,11 @@ static void Fxu_HeapSingleMoveDn( Fxu_HeapSingle * p, Fxu_Single * pSingle );
 Fxu_HeapSingle * Fxu_HeapSingleStart()
 {
     Fxu_HeapSingle * p;
-    p = ALLOC( Fxu_HeapSingle, 1 );
+    p = ABC_ALLOC( Fxu_HeapSingle, 1 );
     memset( p, 0, sizeof(Fxu_HeapSingle) );
     p->nItems      = 0;
     p->nItemsAlloc = 2000;
-    p->pTree       = ALLOC( Fxu_Single *, p->nItemsAlloc + 10 );
+    p->pTree       = ABC_ALLOC( Fxu_Single *, p->nItemsAlloc + 10 );
     p->pTree[0]    = NULL;
     return p;
 }
@@ -79,7 +79,7 @@ Fxu_HeapSingle * Fxu_HeapSingleStart()
 void Fxu_HeapSingleResize( Fxu_HeapSingle * p )
 {
     p->nItemsAlloc *= 2;
-    p->pTree = REALLOC( Fxu_Single *, p->pTree, p->nItemsAlloc + 10 );
+    p->pTree = ABC_REALLOC( Fxu_Single *, p->pTree, p->nItemsAlloc + 10 );
 }
 
 /**Function*************************************************************
@@ -97,9 +97,9 @@ void Fxu_HeapSingleStop( Fxu_HeapSingle * p )
 {
     int i;
     i = 0;
-    free( p->pTree );
+    ABC_FREE( p->pTree );
     i = 1;
-    free( p );
+    ABC_FREE( p );
 }
 
 
diff --git a/src/opt/fxu/fxuInt.h b/src/opt/fxu/fxuInt.h
index 4e3d72eb..7483c896 100644
--- a/src/opt/fxu/fxuInt.h
+++ b/src/opt/fxu/fxuInt.h
@@ -365,7 +365,7 @@ struct FxuSingle // 7 words
 #define Fxu_CubeForEachPair( pCube, pPair, i )\
   for ( i = 0;\
         i < pCube->pVar->nCubes &&\
-        (((unsigned)(PORT_PTRUINT_T)(pPair = pCube->pVar->ppPairs[pCube->iCube][i])) >= 0);\
+        (((unsigned)(ABC_PTRUINT_T)(pPair = pCube->pVar->ppPairs[pCube->iCube][i])) >= 0);\
         i++ )\
         if ( pPair )
 
@@ -421,8 +421,8 @@ extern void Fxu_MatrixRingVarsUnmark( Fxu_Matrix * p );
 // MEM_ALLOC: allocate the given number (Size) of items of type (Type)
 // MEM_FREE:  deallocate the pointer (Pointer) to the given number (Size) of items of type (Type)
 #ifdef USE_SYSTEM_MEMORY_MANAGEMENT
-#define MEM_ALLOC_FXU( Manager, Type, Size )          ((Type *)malloc( (Size) * sizeof(Type) ))
-#define MEM_FREE_FXU( Manager, Type, Size, Pointer )  if ( Pointer ) { free(Pointer); Pointer = NULL; }
+#define MEM_ALLOC_FXU( Manager, Type, Size )          ((Type *)ABC_ALLOC( char, (Size) * sizeof(Type) ))
+#define MEM_FREE_FXU( Manager, Type, Size, Pointer )  if ( Pointer ) { ABC_FREE(Pointer); Pointer = NULL; }
 #else
 #define MEM_ALLOC_FXU( Manager, Type, Size )\
         ((Type *)Fxu_MemFetch( Manager, (Size) * sizeof(Type) ))
diff --git a/src/opt/fxu/fxuMatrix.c b/src/opt/fxu/fxuMatrix.c
index 93ec7b90..590370c9 100644
--- a/src/opt/fxu/fxuMatrix.c
+++ b/src/opt/fxu/fxuMatrix.c
@@ -42,10 +42,10 @@ extern unsigned int Cudd_Prime( unsigned int p );
 Fxu_Matrix * Fxu_MatrixAllocate()
 {
     Fxu_Matrix * p;
-    p = ALLOC( Fxu_Matrix, 1 );
+    p = ABC_ALLOC( Fxu_Matrix, 1 );
     memset( p, 0, sizeof(Fxu_Matrix) );
     p->nTableSize = Cudd_Prime(10000);
-    p->pTable = ALLOC( Fxu_ListDouble, p->nTableSize );
+    p->pTable = ABC_ALLOC( Fxu_ListDouble, p->nTableSize );
     memset( p->pTable, 0, sizeof(Fxu_ListDouble) * p->nTableSize );
 #ifndef USE_SYSTEM_MEMORY_MANAGEMENT
     {
@@ -134,12 +134,12 @@ void Fxu_MatrixDelete( Fxu_Matrix * p )
 #endif
 
     Vec_PtrFree( p->vPairs );
-    FREE( p->pppPairs );
-    FREE( p->ppPairs );
-//    FREE( p->pPairsTemp );
-    FREE( p->pTable );
-    FREE( p->ppVars );
-    FREE( p );
+    ABC_FREE( p->pppPairs );
+    ABC_FREE( p->ppPairs );
+//    ABC_FREE( p->pPairsTemp );
+    ABC_FREE( p->pTable );
+    ABC_FREE( p->ppVars );
+    ABC_FREE( p );
 }
 
 
diff --git a/src/opt/fxu/fxuPair.c b/src/opt/fxu/fxuPair.c
index 87645cc7..62cc792b 100644
--- a/src/opt/fxu/fxuPair.c
+++ b/src/opt/fxu/fxuPair.c
@@ -86,7 +86,7 @@ void Fxu_PairCanonicize( Fxu_Cube ** ppCube1, Fxu_Cube ** ppCube2 )
             pLit2 = pLit2->pHNext;
             continue;
         }
-        assert( pLit1 && pLit2 ); // this is true if the covers are SCC-free
+        assert( pLit1 && pLit2 ); // this is true if the covers are SCC-ABC_FREE
         if ( pLit1->iVar > pLit2->iVar )
         { // swap the cubes
             pCubeTemp = *ppCube1;
@@ -149,7 +149,7 @@ unsigned Fxu_PairHashKeyArray( Fxu_Matrix * p, int piVarsC1[], int piVarsC2[], i
   Synopsis    [Computes the hash key of the divisor represented by the pair of cubes.]
 
   Description [Goes through the variables in both cubes. Skips the identical
-  ones (this corresponds to making the cubes cube-free). Computes the hash 
+  ones (this corresponds to making the cubes cube-ABC_FREE). Computes the hash 
   value of the cubes. Assigns the number of literals in the base and in the 
   cubes without base.]
                
@@ -178,7 +178,7 @@ unsigned Fxu_PairHashKey( Fxu_Matrix * p, Fxu_Cube * pCube1, Fxu_Cube * pCube2,
         if ( pLit1 && pLit2 )
         {
             if ( pLit1->iVar == pLit2->iVar )
-            { // ensure cube-free
+            { // ensure cube-ABC_FREE
                 pLit1 = pLit1->pHNext;
                 pLit2 = pLit2->pHNext;
                 // add this literal to the base
@@ -452,8 +452,8 @@ void Fxu_PairAllocStorage( Fxu_Var * pVar, int nCubes )
 //    assert( pVar->nCubes == 0 );
     pVar->nCubes  = nCubes;
     // allocate memory for all the pairs
-    pVar->ppPairs    = ALLOC( Fxu_Pair **, nCubes );
-    pVar->ppPairs[0] = ALLOC( Fxu_Pair *,  nCubes * nCubes );
+    pVar->ppPairs    = ABC_ALLOC( Fxu_Pair **, nCubes );
+    pVar->ppPairs[0] = ABC_ALLOC( Fxu_Pair *,  nCubes * nCubes );
     memset( pVar->ppPairs[0], 0, sizeof(Fxu_Pair *) * nCubes * nCubes );
     for ( k = 1; k < nCubes; k++ )
         pVar->ppPairs[k] = pVar->ppPairs[k-1] + nCubes;
@@ -497,8 +497,8 @@ void Fxu_PairFreeStorage( Fxu_Var * pVar )
 {
     if ( pVar->ppPairs )
     {
-        FREE( pVar->ppPairs[0] );
-        FREE( pVar->ppPairs );
+        ABC_FREE( pVar->ppPairs[0] );
+        ABC_FREE( pVar->ppPairs );
     }
 }
 
diff --git a/src/opt/fxu/fxuPrint.c b/src/opt/fxu/fxuPrint.c
index 232b109a..652a830e 100644
--- a/src/opt/fxu/fxuPrint.c
+++ b/src/opt/fxu/fxuPrint.c
@@ -161,7 +161,7 @@ void Fxu_MatrixPrintDivisorProfile( FILE * pFile, Fxu_Matrix * p )
     int i;
 
     WeightMax = Fxu_HeapDoubleReadMaxWeight( p->pHeapDouble );
-    pProfile = ALLOC( int, (WeightMax + 1) );
+    pProfile = ABC_ALLOC( int, (WeightMax + 1) );
     memset( pProfile, 0, sizeof(int) * (WeightMax + 1) );
 
     Counter1 = 0;
@@ -184,7 +184,7 @@ void Fxu_MatrixPrintDivisorProfile( FILE * pFile, Fxu_Matrix * p )
         if ( pProfile[i] )
             fprintf( pFile, "Weight   %3d divisors = %6d\n", i, pProfile[i] );
     fprintf( pFile, "End of divisor profile printout\n" );
-    FREE( pProfile );
+    ABC_FREE( pProfile );
 }
 
 
diff --git a/src/opt/fxu/fxuReduce.c b/src/opt/fxu/fxuReduce.c
index 38032bfa..6b892971 100644
--- a/src/opt/fxu/fxuReduce.c
+++ b/src/opt/fxu/fxuReduce.c
@@ -40,7 +40,7 @@ static int Fxu_CountPairDiffs( char * pCover, unsigned char pDiffs[] );
   number of pairs in existence. This procedure adds to the storage of
   divisors exactly the given number of pairs (nPairsMax) while taking
   first those pairs that have the smallest number of literals in their
-  cube-free form.]
+  cube-ABC_FREE form.]
                
   SideEffects []
 
@@ -64,7 +64,7 @@ int Fxu_PreprocessCubePairs( Fxu_Matrix * p, Vec_Ptr_t * vCovers, int nPairsTota
     assert( nPairsMax < nPairsTotal );
 
     // allocate storage for counter of diffs
-    pnLitsDiff = ALLOC( unsigned char, nPairsTotal );
+    pnLitsDiff = ABC_ALLOC( unsigned char, nPairsTotal );
     // go through the covers and precompute the distances between the pairs
     iPair    =  0;
     nBitsMax = -1;
@@ -83,7 +83,7 @@ int Fxu_PreprocessCubePairs( Fxu_Matrix * p, Vec_Ptr_t * vCovers, int nPairsTota
     assert( iPair == nPairsTotal );
 
     // allocate storage for counters of cube pairs by difference
-    pnPairCounters = ALLOC( int, 2 * nBitsMax );
+    pnPairCounters = ABC_ALLOC( int, 2 * nBitsMax );
     memset( pnPairCounters, 0, sizeof(int) * 2 * nBitsMax );
     // count the number of different pairs
     for ( k = 0; k < nPairsTotal; k++ )
@@ -92,16 +92,16 @@ int Fxu_PreprocessCubePairs( Fxu_Matrix * p, Vec_Ptr_t * vCovers, int nPairsTota
     // so that there would be exactly pPairsMax pairs
     if ( pnPairCounters[0] != 0 )
     {
-        printf( "The SOPs of the nodes are not cube-free. Run \"bdd; sop\" before \"fx\".\n" );
+        printf( "The SOPs of the nodes are not cube-ABC_FREE. Run \"bdd; sop\" before \"fx\".\n" );
         return 0;
     }
     if ( pnPairCounters[1] != 0 )
     {
-        printf( "The SOPs of the nodes are not SCC-free. Run \"bdd; sop\" before \"fx\".\n" );
+        printf( "The SOPs of the nodes are not SCC-ABC_FREE. Run \"bdd; sop\" before \"fx\".\n" );
         return 0;
     }
-    assert( pnPairCounters[0] == 0 ); // otherwise, covers are not dup-free
-    assert( pnPairCounters[1] == 0 ); // otherwise, covers are not SCC-free
+    assert( pnPairCounters[0] == 0 ); // otherwise, covers are not dup-ABC_FREE
+    assert( pnPairCounters[1] == 0 ); // otherwise, covers are not SCC-ABC_FREE
     nSum = 0;
     for ( k = 0; k < 2 * nBitsMax; k++ )
     {
@@ -113,7 +113,7 @@ int Fxu_PreprocessCubePairs( Fxu_Matrix * p, Vec_Ptr_t * vCovers, int nPairsTota
             break;
         }
     }
-    FREE( pnPairCounters );
+    ABC_FREE( pnPairCounters );
 
     // set to 0 all the pairs above the cut-off number and quantity
     iQuant = 0;
@@ -156,8 +156,8 @@ int Fxu_PreprocessCubePairs( Fxu_Matrix * p, Vec_Ptr_t * vCovers, int nPairsTota
                     }
         }
     assert( iPair == nPairsTotal );
-    FREE( pnLitsDiff );
-//PRT( "Preprocess", clock() - clk );
+    ABC_FREE( pnLitsDiff );
+//ABC_PRT( "Preprocess", clock() - clk );
     return 1;
 }
 
@@ -171,7 +171,7 @@ int Fxu_PreprocessCubePairs( Fxu_Matrix * p, Vec_Ptr_t * vCovers, int nPairsTota
   entries as there are different pairs of cubes in the cover: n(n-1)/2.
   Fills out the array pDiffs with the following info: For each cube
   pair, included in the array is the number of literals in both cubes
-  after they are made cube free.]
+  after they are made cube ABC_FREE.]
                
   SideEffects []
 
diff --git a/src/opt/fxu/fxuSelect.c b/src/opt/fxu/fxuSelect.c
index b9265487..20f5ab97 100644
--- a/src/opt/fxu/fxuSelect.c
+++ b/src/opt/fxu/fxuSelect.c
@@ -416,7 +416,7 @@ void Fxu_MatrixGetDoubleVars( Fxu_Matrix * p, Fxu_Double * pDouble,
         if ( pLit1 && pLit2 )
         {
             if ( pLit1->iVar == pLit2->iVar )
-            { // ensure cube-free
+            { // ensure cube-ABC_FREE
                 pLit1 = pLit1->pHNext;
                 pLit2 = pLit2->pHNext;
             }
diff --git a/src/opt/fxu/fxuSingle.c b/src/opt/fxu/fxuSingle.c
index d2e3607c..6e90a2a2 100644
--- a/src/opt/fxu/fxuSingle.c
+++ b/src/opt/fxu/fxuSingle.c
@@ -59,11 +59,11 @@ void Fxu_MatrixComputeSingles( Fxu_Matrix * p, int fUse0, int nSingleMax )
         int * pWeigtCounts, nDivCount, Weight, i, c;;
         assert( Vec_PtrSize(vSingles) % 3 == 0 );
         // count how many divisors have the given weight
-        pWeigtCounts = ALLOC( int, 1000 );
+        pWeigtCounts = ABC_ALLOC( int, 1000 );
         memset( pWeigtCounts, 0, sizeof(int) * 1000 );
         for ( i = 2; i < Vec_PtrSize(vSingles); i += 3 )
         {
-            Weight = (int)(PORT_PTRUINT_T)Vec_PtrEntry(vSingles, i);
+            Weight = (int)(ABC_PTRUINT_T)Vec_PtrEntry(vSingles, i);
             if ( Weight >= 999 )
                 pWeigtCounts[999]++;
             else
@@ -77,12 +77,12 @@ void Fxu_MatrixComputeSingles( Fxu_Matrix * p, int fUse0, int nSingleMax )
             if ( nDivCount >= nSingleMax )
                 break;
         }
-        free( pWeigtCounts );
+        ABC_FREE( pWeigtCounts );
         // collect singles with the given costs
         k = 0;
         for ( i = 2; i < Vec_PtrSize(vSingles); i += 3 )
         {
-            Weight = (int)(PORT_PTRUINT_T)Vec_PtrEntry(vSingles, i);
+            Weight = (int)(ABC_PTRUINT_T)Vec_PtrEntry(vSingles, i);
             if ( Weight < c )
                 continue;
             Vec_PtrWriteEntry( vSingles, k++, Vec_PtrEntry(vSingles, i-2) );
@@ -102,7 +102,7 @@ void Fxu_MatrixComputeSingles( Fxu_Matrix * p, int fUse0, int nSingleMax )
         Fxu_MatrixAddSingle( p, 
             Vec_PtrEntry(vSingles,i), 
             Vec_PtrEntry(vSingles,i+1), 
-            (int)(PORT_PTRUINT_T)Vec_PtrEntry(vSingles,i+2) );
+            (int)(ABC_PTRUINT_T)Vec_PtrEntry(vSingles,i+2) );
     }
     Vec_PtrFree( vSingles );
 }
@@ -159,7 +159,7 @@ void Fxu_MatrixComputeSinglesOneCollect( Fxu_Matrix * p, Fxu_Var * pVar, Vec_Ptr
         {
             Vec_PtrPush( vSingles, pVar2 );
             Vec_PtrPush( vSingles, pVar );
-            Vec_PtrPush( vSingles, (void *)(PORT_PTRUINT_T)WeightCur );
+            Vec_PtrPush( vSingles, (void *)(ABC_PTRUINT_T)WeightCur );
         }
     }
 
diff --git a/src/opt/fxu/fxuUpdate.c b/src/opt/fxu/fxuUpdate.c
index 274f79f6..cdbe313d 100644
--- a/src/opt/fxu/fxuUpdate.c
+++ b/src/opt/fxu/fxuUpdate.c
@@ -344,7 +344,7 @@ void Fxu_UpdateMatrixDoubleCreateCubes( Fxu_Matrix * p, Fxu_Cube * pCube1, Fxu_C
         if ( pLit1 && pLit2 )
         {
             if ( pLit1->iVar == pLit2->iVar )
-            { // skip the cube free part
+            { // skip the cube ABC_FREE part
                 pLit1 = pLit1->pHNext;
                 pLit2 = pLit2->pHNext;
                 nBase++;