Changes to the parser.

src/base/abci/abc.c

@@ -10834,6 +10834,10 @@ int Abc_CommandTest( Abc_Frame_t * pAbc, int argc, char ** argv )
         Abc_IsopTestNew();
     }
 */
+    {
+        extern void Cba_PrsReadBlifTest();
+        Cba_PrsReadBlifTest();
+    }
     return 0;
 usage:
     Abc_Print( -2, "usage: test [-CKDNM] [-aovwh] <file_name>\n" );

src/base/cba/cba.h

@@ -150,7 +150,7 @@ static inline Cba_Ntk_t * Cba_NtkAlloc( Cba_Man_t * p, char * pName )
 {
     Cba_Ntk_t * pNtk = ABC_CALLOC( Cba_Ntk_t, 1 );
     pNtk->pDesign = p;
-    pNtk->pName = pName;
+    pNtk->pName = Abc_UtilStrsav(pName);
     Vec_PtrPush( &p->vNtks, pNtk );
     return pNtk;
 }
@@ -169,9 +169,13 @@ static inline void Cba_NtkFree( Cba_Ntk_t * p )
     Vec_IntErase( &p->vNameIds );
     Vec_IntErase( &p->vRanges );
     Vec_IntErase( &p->vCopies );
+    ABC_FREE( p->pName );
     ABC_FREE( p );
 }
-
+static inline int Cba_NtkMemory( Cba_Ntk_t * p )
+{
+    return Vec_WecMemory(&p->vFanins);
+}
 
 static inline Cba_Man_t * Cba_ManAlloc( char * pFileName )
 {
@@ -193,6 +197,7 @@ static inline void Cba_ManFree( Cba_Man_t * p )
     Cba_Ntk_t * pNtk; int i;
     Cba_ManForEachNtk( p, pNtk, i )
         Cba_NtkFree( pNtk );
+    ABC_FREE( p->vNtks.pArray );
     Mem_FlexStop( p->pMem, 0 );
     // design names
     Abc_NamStop( p->pNames );
@@ -202,6 +207,19 @@ static inline void Cba_ManFree( Cba_Man_t * p )
     ABC_FREE( p->pSpec );
     ABC_FREE( p );
 }
+static inline int Cba_ManMemory( Cba_Man_t * p )
+{
+    Cba_Ntk_t * pNtk; int i;
+    int nMem = sizeof(Cba_Man_t);
+    nMem += Abc_NamMemUsed(p->pNames);
+    nMem += Abc_NamMemUsed(p->pModels);
+    nMem += Abc_NamMemUsed(p->pFuncs);
+    nMem += Mem_FlexReadMemUsage(p->pMem);
+    nMem += (int)Vec_PtrMemory(&p->vNtks);
+    Cba_ManForEachNtk( p, pNtk, i )
+        nMem += Cba_NtkMemory( pNtk );
+    return nMem;
+}
 
 
 /*=== cbaReadBlif.c =========================================================*/

src/base/cba/cbaPrs.h

@@ -78,19 +78,19 @@ struct Cba_Prs_t_
     Cba_Man_t *  pDesign; 
     // interface collected by the parser
     int          iModuleName; // name Id
-    Vec_Int_t *  vInoutsCur;  // inouts
-    Vec_Int_t *  vInputsCur;  // inputs 
-    Vec_Int_t *  vOutputsCur; // outputs
-    Vec_Int_t *  vWiresCur;   // wires
+    Vec_Int_t    vInoutsCur;  // inouts
+    Vec_Int_t    vInputsCur;  // inputs 
+    Vec_Int_t    vOutputsCur; // outputs
+    Vec_Int_t    vWiresCur;   // wires
     // objects collected by the parser
-    Vec_Int_t *  vTypesCur;   // Cba_PrsType_t
-    Vec_Int_t *  vFuncsCur;   // functions (node->func; box->module; gate->cell; latch->init; concat->unused)
-    Vec_Int_t *  vInstIdsCur; // instance names
-    Vec_Wec_t *  vFaninsCur;  // instances
+    Vec_Int_t    vTypesCur;   // Cba_PrsType_t
+    Vec_Int_t    vFuncsCur;   // functions (node->func; box->module; gate->cell; latch->init; concat->unused)
+    Vec_Int_t    vInstIdsCur; // instance names
+    Vec_Wec_t    vFaninsCur;  // instances
     // temporary data
-    Vec_Str_t *  vCover;      // one SOP cover
-    Vec_Int_t *  vTemp;       // array of tokens
-    Vec_Int_t *  vTemp2;      // array of tokens
+    Vec_Str_t    vCover;      // one SOP cover
+    Vec_Int_t    vTemp;       // array of tokens
+    Vec_Int_t    vTemp2;      // array of tokens
     // error handling
     char ErrorStr[1000];      // error
 };
@@ -132,16 +132,16 @@ static inline void Cba_PrsSetupVecInt( Cba_Prs_t * p, Vec_Int_t * vTo, Vec_Int_t
 static inline Cba_Ntk_t * Cba_PrsAddCurrentModel( Cba_Prs_t * p, int iNameId )
 {
     Cba_Ntk_t * pNtk = Cba_NtkAlloc( p->pDesign, Abc_NamStr(p->pDesign->pNames, iNameId) );
-    assert( Vec_IntSize(p->vInputsCur) != 0 && Vec_IntSize(p->vOutputsCur) != 0 );
-    Cba_PrsSetupVecInt( p, &pNtk->vInouts,  p->vInoutsCur  );
-    Cba_PrsSetupVecInt( p, &pNtk->vInputs,  p->vInputsCur  );
-    Cba_PrsSetupVecInt( p, &pNtk->vOutputs, p->vOutputsCur );
-    Cba_PrsSetupVecInt( p, &pNtk->vWires,   p->vWiresCur   );
-    Cba_PrsSetupVecInt( p, &pNtk->vTypes,   p->vTypesCur   );
-    Cba_PrsSetupVecInt( p, &pNtk->vFuncs,   p->vFuncsCur   );
-    Cba_PrsSetupVecInt( p, &pNtk->vInstIds, p->vInstIdsCur );
-    pNtk->vFanins = *p->vFaninsCur;
-    Vec_WecZero( &pNtk->vFanins );
+    assert( Vec_IntSize(&p->vInputsCur) != 0 || Vec_IntSize(&p->vOutputsCur) != 0 );
+    Cba_PrsSetupVecInt( p, &pNtk->vInouts,  &p->vInoutsCur  );
+    Cba_PrsSetupVecInt( p, &pNtk->vInputs,  &p->vInputsCur  );
+    Cba_PrsSetupVecInt( p, &pNtk->vOutputs, &p->vOutputsCur );
+    Cba_PrsSetupVecInt( p, &pNtk->vWires,   &p->vWiresCur   );
+    Cba_PrsSetupVecInt( p, &pNtk->vTypes,   &p->vTypesCur   );
+    Cba_PrsSetupVecInt( p, &pNtk->vFuncs,   &p->vFuncsCur   );
+    Cba_PrsSetupVecInt( p, &pNtk->vInstIds, &p->vInstIdsCur );
+    pNtk->vFanins = p->vFaninsCur;
+    Vec_WecZero( &p->vFaninsCur );
     return pNtk;
 }
 
@@ -185,29 +185,25 @@ static inline Cba_Prs_t * Cba_PrsAlloc( char * pFileName )
     p->pLimit  = pLimit;
     p->pCur    = pBuffer;
     p->pDesign = Cba_ManAlloc( pFileName );
-    // temporaries
-    p->vCover = Vec_StrAlloc( 1000 );
-    p->vTemp  = Vec_IntAlloc( 1000 );
-    p->vTemp2 = Vec_IntAlloc( 1000 );
     return p;
 }
 static inline void Cba_PrsFree( Cba_Prs_t * p )
 {
     if ( p->pDesign )
         Cba_ManFree( p->pDesign );
-    Vec_IntFreeP( &p->vInoutsCur );
-    Vec_IntFreeP( &p->vInputsCur );
-    Vec_IntFreeP( &p->vOutputsCur );
-    Vec_IntFreeP( &p->vWiresCur );
-
-    Vec_IntFreeP( &p->vTypesCur );
-    Vec_IntFreeP( &p->vFuncsCur );
-    Vec_IntFreeP( &p->vInstIdsCur );
-    Vec_WecFreeP( &p->vFaninsCur );
+    Vec_IntErase( &p->vInoutsCur );
+    Vec_IntErase( &p->vInputsCur );
+    Vec_IntErase( &p->vOutputsCur );
+    Vec_IntErase( &p->vWiresCur );
+
+    Vec_IntErase( &p->vTypesCur );
+    Vec_IntErase( &p->vFuncsCur );
+    Vec_IntErase( &p->vInstIdsCur );
+    ABC_FREE( p->vFaninsCur.pArray );
     // temporary
-    Vec_StrFreeP( &p->vCover );
-    Vec_IntFreeP( &p->vTemp );
-    Vec_IntFreeP( &p->vTemp2 );
+    Vec_StrErase( &p->vCover );
+    Vec_IntErase( &p->vTemp );
+    Vec_IntErase( &p->vTemp2 );
     ABC_FREE( p->pBuffer );
     ABC_FREE( p );
 }

src/base/cba/cbaReadVer.c

@@ -264,24 +264,24 @@ static inline int Cba_PrsReadRange( Cba_Prs_t * p )
 {
     if ( !Cba_PrsIsChar(p, '[') )
         return 0;
-    Vec_StrClear( p->vCover );
-    Vec_StrPush( p->vCover, *p->pCur++ );
+    Vec_StrClear( &p->vCover );
+    Vec_StrPush( &p->vCover, *p->pCur++ );
     Cba_PrsUtilSkipSpaces( p );
     if ( !Cba_PrsIsDigit(p) )     return Cba_PrsErrorSet(p, "Cannot read digit in range specification.", 2);
     while ( Cba_PrsIsDigit(p) )
-        Vec_StrPush( p->vCover, *p->pCur++ );
+        Vec_StrPush( &p->vCover, *p->pCur++ );
     Cba_PrsUtilSkipSpaces( p );
     if ( Cba_PrsIsChar(p, ':') )
     {
-        Vec_StrPush( p->vCover, *p->pCur++ );
+        Vec_StrPush( &p->vCover, *p->pCur++ );
         if ( !Cba_PrsIsDigit(p) ) return Cba_PrsErrorSet(p, "Cannot read digit in range specification.", 2);
         while ( Cba_PrsIsDigit(p) )
-            Vec_StrPush( p->vCover, *p->pCur++ );
+            Vec_StrPush( &p->vCover, *p->pCur++ );
         Cba_PrsUtilSkipSpaces( p );
     }
     if ( !Cba_PrsIsChar(p, ']') ) return Cba_PrsErrorSet(p, "Cannot read closing brace in range specification.", 2);
-    Vec_StrPush( p->vCover, *p->pCur++ );
-    return Abc_NamStrFindOrAddLim( p->pDesign->pNames, Vec_StrArray(p->vCover), Vec_StrArray(p->vCover)+Vec_StrSize(p->vCover), NULL );
+    Vec_StrPush( &p->vCover, *p->pCur++ );
+    return Abc_NamStrFindOrAddLim( p->pDesign->pNames, Vec_StrArray(&p->vCover), Vec_StrArray(&p->vCover)+Vec_StrSize(&p->vCover), NULL );
 }
 static inline void Cba_PrsReadSignalList( Cba_Prs_t * p, Vec_Int_t * vTemp )
 {
@@ -303,12 +303,12 @@ static inline void Cba_PrsReadSignalList( Cba_Prs_t * p, Vec_Int_t * vTemp )
 static inline int Cba_PrsReadDeclaration( Cba_Prs_t * p, int Type )
 {
     int NameId, RangeId, RangeIdTemp;
-    Vec_Int_t * vSigs[4] = { p->vInoutsCur, p->vInputsCur, p->vOutputsCur, p->vWiresCur };
+    Vec_Int_t * vSigs[4] = { &p->vInoutsCur, &p->vInputsCur, &p->vOutputsCur, &p->vWiresCur };
     assert( Type >= CBA_VER_INOUT && Type <= CBA_VER_WIRE );
     Cba_PrsUtilSkipSpaces( p );
     RangeId = Cba_PrsReadRange( p );
-    Cba_PrsReadSignalList( p, p->vTemp );
-    Vec_IntForEachEntryDouble( p->vTemp, NameId, RangeId, RangeIdTemp )
+    Cba_PrsReadSignalList( p, &p->vTemp );
+    Vec_IntForEachEntryDouble( &p->vTemp, NameId, RangeId, RangeIdTemp )
     {
         if ( !RangeIdTemp )      return Cba_PrsErrorSet(p, "Range is specified twice in the declaration.", 0);
         Vec_IntPushTwo( vSigs[Type - CBA_VER_INOUT], NameId, RangeId );
@@ -317,17 +317,17 @@ static inline int Cba_PrsReadDeclaration( Cba_Prs_t * p, int Type )
 }
 static inline int Cba_PrsReadConcat( Cba_Prs_t * p )
 {
-    int iToken = Vec_WecSize( p->vFaninsCur );
+    int iToken = Vec_WecSize( &p->vFaninsCur );
     assert( Cba_PrsIsChar(p, '{') );
     p->pCur++;
-    Cba_PrsReadSignalList( p, p->vTemp2 );
+    Cba_PrsReadSignalList( p, &p->vTemp2 );
     if ( !Cba_PrsIsChar(p, '}') )  return Cba_PrsErrorSet(p, "Cannot read concatenation.", 0);
     p->pCur++;
     // assign
-    Vec_IntPush( p->vTypesCur, CBA_PRS_CONCAT );
-    Vec_IntPush( p->vFuncsCur, 0 );
-    Vec_IntPush( p->vInstIdsCur, 0 );
-    Cba_PrsSetupVecInt( p, Vec_WecPushLevel(p->vFaninsCur), p->vTemp2 );
+    Vec_IntPush( &p->vTypesCur, CBA_PRS_CONCAT );
+    Vec_IntPush( &p->vFuncsCur, 0 );
+    Vec_IntPush( &p->vInstIdsCur, 0 );
+    Cba_PrsSetupVecInt( p, Vec_WecPushLevel(&p->vFaninsCur), &p->vTemp2 );
     return iToken;
 }
 
@@ -335,7 +335,7 @@ static inline int Cba_PrsReadInstance( Cba_Prs_t * p, int Func )
 {
     // have to assign Type, Func, InstId, vFanins
     int FormId, NameId, RangeId, Type, InstId;
-    Vec_IntClear( p->vTemp );
+    Vec_IntClear( &p->vTemp );
     Cba_PrsUtilSkipSpaces( p );
     if ( Cba_PrsIsChar(p, '(') ) // node
     {
@@ -355,7 +355,7 @@ static inline int Cba_PrsReadInstance( Cba_Prs_t * p, int Func )
                 NameId  = Cba_PrsReadName( p );
                 RangeId = Cba_PrsReadRange( p );
             }
-            Vec_IntPushTwo( p->vTemp, NameId, RangeId );
+            Vec_IntPushTwo( &p->vTemp, NameId, RangeId );
             Cba_PrsUtilSkipSpaces( p );
             if ( Cba_PrsIsChar(p, ')') )
                 break;
@@ -390,7 +390,7 @@ static inline int Cba_PrsReadInstance( Cba_Prs_t * p, int Func )
                 NameId  = Cba_PrsReadName( p );
                 RangeId = Cba_PrsReadRange( p );
             }
-            Vec_IntPushTwo( p->vTemp, NameId, RangeId );
+            Vec_IntPushTwo( &p->vTemp, NameId, RangeId );
             Cba_PrsUtilSkipSpaces( p );
             if ( !Cba_PrsIsChar(p, ')') ) return Cba_PrsErrorSet(p, "Expecting opening paranthesis after the acctual name.", 2);
             p->pCur++;
@@ -402,10 +402,10 @@ static inline int Cba_PrsReadInstance( Cba_Prs_t * p, int Func )
         }
     }
     // assign
-    Vec_IntPush( p->vTypesCur, Type );
-    Vec_IntPush( p->vFuncsCur, Func );
-    Vec_IntPush( p->vInstIdsCur, InstId );
-    Cba_PrsSetupVecInt( p, Vec_WecPushLevel(p->vFaninsCur), p->vTemp );
+    Vec_IntPush( &p->vTypesCur, Type );
+    Vec_IntPush( &p->vFuncsCur, Func );
+    Vec_IntPush( &p->vInstIdsCur, InstId );
+    Cba_PrsSetupVecInt( p, Vec_WecPushLevel(&p->vFaninsCur), &p->vTemp );
     return 0;
 }
 
@@ -414,7 +414,7 @@ static inline int Cba_PrsReadInstance( Cba_Prs_t * p, int Func )
 static inline int Cba_PrsReadModule( Cba_Prs_t * p )
 {
     int fKnown, iToken, iNameId;
-    assert( Vec_IntSize(p->vInputsCur) == 0 && Vec_IntSize(p->vOutputsCur) == 0 );
+    assert( Vec_IntSize(&p->vInputsCur) == 0 && Vec_IntSize(&p->vOutputsCur) == 0 );
     Cba_PrsUtilSkipSpaces( p );
     if ( !Cba_PrsOk(p) )          return 0;
     // read keyword

src/base/cba/cbaWriteBlif.c

@@ -57,6 +57,7 @@ void Cba_PrsWriteBlifArray2( FILE * pFile, Cba_Ntk_t * p, Vec_Int_t * vFanins )
     assert( Vec_IntSize(vFanins) % 2 == 0 );
     Vec_IntForEachEntryDouble( vFanins, FormId, NameId, i )
         fprintf( pFile, " %s=%s", Cba_NtkStr(p, FormId), Cba_NtkStr(p, NameId) );
+    fprintf( pFile, "\n" );
 }
 void Cba_PrsWriteBlifLines( FILE * pFile, Cba_Ntk_t * p )
 {
@@ -67,19 +68,19 @@ void Cba_PrsWriteBlifLines( FILE * pFile, Cba_Ntk_t * p )
         {
             fprintf( pFile, ".names" );
             Cba_PrsWriteBlifArray( pFile, p, vFanins, 1 );
-            fprintf( pFile, " %s", Cba_NtkStr(p,  Func) );
+            fprintf( pFile, "%s", Cba_NtkFuncStr(p,  Func) );
         }
         else if ( Type == CBA_PRS_BOX ) // .names/assign/box2 (no formal/actual binding)
         {
             fprintf( pFile, ".subckt" );
-            fprintf( pFile, " %s", Cba_NtkFuncStr(p,  Func) );
+            fprintf( pFile, " %s", Cba_NtkStr(p,  Func) );
             Cba_PrsWriteBlifArray2( pFile, p, vFanins );
         }
         else if ( Type == CBA_PRS_LATCH ) // .names/assign/box2 (no formal/actual binding)
         {
             fprintf( pFile, ".latch" );
-            fprintf( pFile, " %s", Cba_NtkFuncStr(p,  Vec_IntEntry(vFanins, 1)) );
-            fprintf( pFile, " %s", Cba_NtkFuncStr(p,  Vec_IntEntry(vFanins, 0)) );
+            fprintf( pFile, " %s", Cba_NtkStr(p,  Vec_IntEntry(vFanins, 1)) );
+            fprintf( pFile, " %s", Cba_NtkStr(p,  Vec_IntEntry(vFanins, 0)) );
             fprintf( pFile, " %c\n", '0' + Func );
         }
 }
@@ -89,7 +90,9 @@ void Cba_PrsWriteBlifNtk( FILE * pFile, Cba_Ntk_t * p )
     assert( Vec_IntSize(&p->vFuncs)   == Cba_NtkObjNum(p) );
     // write header
     fprintf( pFile, ".model %s\n", Cba_NtkName(p) );
+    if ( Vec_IntSize(&p->vInouts) )
     fprintf( pFile, ".inouts" );
+    if ( Vec_IntSize(&p->vInouts) )
     Cba_PrsWriteBlifArray( pFile, p, &p->vInouts, 0 );
     fprintf( pFile, ".inputs" );
     Cba_PrsWriteBlifArray( pFile, p, &p->vInputs, 0 );
@@ -97,7 +100,7 @@ void Cba_PrsWriteBlifNtk( FILE * pFile, Cba_Ntk_t * p )
     Cba_PrsWriteBlifArray( pFile, p, &p->vOutputs, 0 );
     // write objects
     Cba_PrsWriteBlifLines( pFile, p );
-    fprintf( pFile, ".end\n" );
+    fprintf( pFile, ".end\n\n" );
 }
 void Cba_PrsWriteBlif( char * pFileName, Cba_Man_t * pDes )
 {

src/misc/util/utilNam.c

@@ -257,7 +257,7 @@ int Abc_NamStrHash( const char * pStr, const char * pLim, int nTableSize )
     unsigned i, uHash;
     if ( pLim )
     {
-        for ( uHash = 0, i = 0; pStr < pLim; i++ )
+        for ( uHash = 0, i = 0; pStr+i < pLim; i++ )
             if ( i & 1 ) 
                 uHash *= pStr[i] * s_FPrimes[i & 0x7F];
             else
@@ -285,6 +285,23 @@ int Abc_NamStrHash( const char * pStr, const char * pLim, int nTableSize )
   SeeAlso     []
 
 ***********************************************************************/
+static inline int Abc_NamStrcmp( char * pStr, char * pLim, char * pThis )
+{
+    if ( pLim )
+    {
+        while ( pStr < pLim )
+            if ( *pStr++ != *pThis++ )
+                return 1;
+        return *pThis != '\0';
+    }
+    else
+    {
+        while ( *pStr )
+            if ( *pStr++ != *pThis++ )
+                return 1;
+        return *pThis != '\0';
+    }
+}
 static inline int * Abc_NamStrHashFind( Abc_Nam_t * p, const char * pStr, const char * pLim )
 {
     char * pThis;
@@ -293,7 +310,7 @@ static inline int * Abc_NamStrHashFind( Abc_Nam_t * p, const char * pStr, const
     for ( pThis = (*pPlace)? Abc_NamIntToStr(p, *pPlace) : NULL; 
           pThis;    pPlace = Abc_NamIntToNextP(p, *pPlace), 
           pThis = (*pPlace)? Abc_NamIntToStr(p, *pPlace) : NULL )
-              if ( !strcmp( pStr, pThis ) )
+              if ( !Abc_NamStrcmp( (char *)pStr, (char *)pLim, pThis ) )
                   break;
     return pPlace;
 }

src/misc/vec/vecStr.h

@@ -201,6 +201,18 @@ static inline Vec_Str_t * Vec_StrDupArray( Vec_Str_t * pVec )
   SeeAlso     []
 
 ***********************************************************************/
+static inline void Vec_StrZero( Vec_Str_t * p )
+{
+    p->pArray = NULL;
+    p->nSize = 0;
+    p->nCap = 0;
+}
+static inline void Vec_StrErase( Vec_Str_t * p )
+{
+    ABC_FREE( p->pArray );
+    p->nSize = 0;
+    p->nCap = 0;
+}
 static inline void Vec_StrFree( Vec_Str_t * p )
 {
     ABC_FREE( p->pArray );