From 11f1a249ae9dc3fab0a24eab02ee605fd58c2471 Mon Sep 17 00:00:00 2001 From: Alan Mishchenko Date: Sun, 1 May 2016 17:43:50 -0700 Subject: Updating GIG parser. --- src/aig/gia/giaGig.c | 564 +++++++++++++++++++++++++++++++++++---------------- 1 file changed, 384 insertions(+), 180 deletions(-) (limited to 'src/aig/gia/giaGig.c') diff --git a/src/aig/gia/giaGig.c b/src/aig/gia/giaGig.c index 7c02e7e9..4e24723f 100644 --- a/src/aig/gia/giaGig.c +++ b/src/aig/gia/giaGig.c @@ -29,32 +29,63 @@ ABC_NAMESPACE_IMPL_START /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// +#define MAX_LINE 1000000 + +// network types enum { - GIG_NONE = 0, - GIG_RESET = 1, - GIG_PI = 2, - GIG_PO = 3, - GIG_SEQ = 4, - GIG_LUT = 5, - GIG_DELAY = 6, - GIG_BOX = 7, - GIG_SEL = 8, - GIG_BAR = 9, - GIG_UNUSED = 10 + GLS_NONE = -1, // not used + GLS_ZERO = 0, // zero + GLS_ONE = 1, // one + GLS_PI = 2, // primary input + GLS_PO = 3, // primary output + GLS_BAR = 4, // barrier + GLS_SEQ = 5, // sequential + GLS_SEL = 6, // fan + GLS_LUT4 = 7, // LUT4 + GLS_LUT6 = 8, // LUT6 + GLS_BOX = 9, // sequential box + GLS_DEL = 10, // delay box + GLS_FINAL }; -static char * s_GigNames[GIG_UNUSED] = +static char * s_Strs[GLS_FINAL] = { - "NONE", // GIG_NONE = 0 - "Reset", // GIG_RESET = 1 - "PI", // GIG_PI = 2 - "PO", // GIG_PO = 3 - "Seq", // GIG_SEQ = 4 - "Lut4", // GIG_LUT = 5 - "Delay", // GIG_DELAY = 6 - "Box", // GIG_BOX = 7 - "Sel", // GIG_SEL = 8 - "Bar" // GIG_BAR = 9 + "0", // GLS_ZERO = 0, // zero + "1", // GLS_ONE = 1, // one + "PI", // GLS_PI = 2, // primary input + "PO", // GLS_PO = 3, // primary output + "Bar", // GLS_BAR = 4, // barrier + "Seq", // GLS_SEQ = 5, // sequential + "Sel", // GLS_SEL = 6, // fan + "Lut4", // GLS_LUT4 = 7, // LUT4 + "Lut6", // GLS_LUT6 = 8, // LUT6 + "Box", // GLS_BOX = 9, // sequential box + "Del" // GLS_DEL = 10, // delay box +}; + +typedef struct Gls_Man_t_ Gls_Man_t; +struct Gls_Man_t_ +{ + // general + Vec_Str_t * vLines; // line types + Vec_Str_t * vTypes; // gate types + Vec_Int_t * vIndexes; // gate indexes + // specific types + Vec_Int_t * vLut4s; // 4-LUTs (4-tuples) + Vec_Int_t * vLut4TTs; // truth tables + Vec_Int_t * vLut6s; // 6-LUTs (6-tuples) + Vec_Wrd_t * vLut6TTs; // truth tables + Vec_Int_t * vBoxes; // boxes (5-tuples) + Vec_Wec_t * vDelayIns; // delay fanins + Vec_Wec_t * vDelayOuts; // delay fanouts + Vec_Int_t * vDelays; // delay values + // ordering + Vec_Int_t * vOrderPis; + Vec_Int_t * vOrderPos; + Vec_Int_t * vOrderBoxes; + Vec_Int_t * vOrderDelays; + Vec_Int_t * vOrderLuts; + Vec_Int_t * vOrderSeqs; }; //////////////////////////////////////////////////////////////////////// @@ -72,22 +103,50 @@ static char * s_GigNames[GIG_UNUSED] = SeeAlso [] ***********************************************************************/ -int * Gia_ManGigCount( Vec_Int_t * vObjs, Vec_Int_t * vStore ) +Gls_Man_t * Gls_ManAlloc( Vec_Str_t * vLines, int * pCounts ) { - static int nObjs[GIG_UNUSED]; int i; - for ( i = 0; i < GIG_UNUSED; i++ ) - nObjs[i] = 0; - for ( i = 0; i < Vec_IntSize(vObjs); i++ ) - nObjs[Vec_IntEntry(vStore, Vec_IntEntry(vObjs,i) + 1)]++; - return nObjs; + Gls_Man_t * p = ABC_CALLOC( Gls_Man_t, 1 ); + p->vLines = vLines; + p->vTypes = Vec_StrStart( Vec_StrSize(vLines)+100 ); + p->vIndexes = Vec_IntStart( Vec_StrSize(vLines)+100 ); + p->vLut4s = Vec_IntAlloc( 4 * pCounts[GLS_LUT4] ); + p->vLut4TTs = Vec_IntAlloc( pCounts[GLS_LUT4] ); + p->vLut6s = Vec_IntAlloc( 6 * pCounts[GLS_LUT6] ); + p->vLut6TTs = Vec_WrdAlloc( pCounts[GLS_LUT6] ); + p->vBoxes = Vec_IntAlloc( 5 * pCounts[GLS_BOX] ); + p->vDelays = Vec_IntAlloc( pCounts[GLS_DEL] ); + p->vDelayIns = Vec_WecAlloc( pCounts[GLS_DEL] ); + p->vDelayOuts = Vec_WecAlloc( pCounts[GLS_DEL] ); + // ordering + p->vOrderPis = Vec_IntAlloc( pCounts[GLS_PI] ); + p->vOrderPos = Vec_IntAlloc( pCounts[GLS_PO] ); + p->vOrderBoxes = Vec_IntAlloc( pCounts[GLS_BOX] ); + p->vOrderDelays = Vec_IntAlloc( pCounts[GLS_DEL] ); + p->vOrderLuts = Vec_IntAlloc( pCounts[GLS_LUT4] + pCounts[GLS_LUT6] + 2*pCounts[GLS_BAR] ); + p->vOrderSeqs = Vec_IntAlloc( pCounts[GLS_SEQ] ); + return p; } -void Gia_ManGigPrint( int * nObjs ) +void Gls_ManStop( Gls_Man_t * p ) { - int i; - printf( "Statistics: " ); - for ( i = 1; i < GIG_UNUSED; i++ ) - printf( "%s = %d ", s_GigNames[i], nObjs[i] ); - printf( "\n" ); + Vec_StrFree( p->vLines ); + Vec_StrFree( p->vTypes ); + Vec_IntFree( p->vIndexes ); + Vec_IntFree( p->vLut4s ); + Vec_IntFree( p->vLut4TTs ); + Vec_IntFree( p->vLut6s ); + Vec_WrdFree( p->vLut6TTs ); + Vec_IntFree( p->vBoxes ); + Vec_IntFree( p->vDelays ); + Vec_WecFree( p->vDelayIns ); + Vec_WecFree( p->vDelayOuts ); + // ordering + Vec_IntFree( p->vOrderPis ); + Vec_IntFree( p->vOrderPos ); + Vec_IntFree( p->vOrderBoxes ); + Vec_IntFree( p->vOrderDelays ); + Vec_IntFree( p->vOrderLuts ); + Vec_IntFree( p->vOrderSeqs ); + ABC_FREE( p ); } /**Function************************************************************* @@ -101,27 +160,209 @@ void Gia_ManGigPrint( int * nObjs ) SeeAlso [] ***********************************************************************/ -void Gia_ManPrintDelays( Vec_Int_t * vObjs, Vec_Int_t * vStore ) +Vec_Str_t * Gls_ManCount( FILE * pFile, int pCounts[GLS_FINAL] ) { - Vec_Int_t * vFanCount = Vec_IntStart( Vec_IntSize(vObjs) + 100 ); - int i, * pEntry;//, Counter = 0; - for ( i = 0; i < Vec_IntSize(vObjs); i++ ) + char * pLine, * pBuffer = ABC_ALLOC(char, MAX_LINE); int Type; + Vec_Str_t * vLines = Vec_StrAlloc( 10000 ); + memset( pCounts, 0, sizeof(int)*GLS_FINAL ); + while ( fgets( pBuffer, MAX_LINE, pFile ) != NULL ) { - pEntry = Vec_IntEntryP( vStore, Vec_IntEntry(vObjs,i) ); - if ( pEntry[1] != GIG_SEL ) - continue; - assert( pEntry[2] == 1 ); - Vec_IntAddToEntry( vFanCount, pEntry[3], 1 ); + pLine = pBuffer; + while ( *pLine ) + if ( *pLine++ == '=' ) + break; + while ( *pLine == ' ' ) + pLine++; + if ( *pLine == 'L' ) + { + if ( pLine[3] == '4' ) + Type = GLS_LUT4; + else if ( pLine[3] == '6' ) + Type = GLS_LUT6; + else assert( 0 ); + } + else if ( *pLine == 'P' ) + { + if ( pLine[1] == 'I' ) + Type = GLS_PI; + else if ( pLine[1] == 'O' ) + Type = GLS_PO; + else assert( 0 ); + } + else if ( *pLine == 'B' ) + { + if ( pLine[1] == 'o' ) + Type = GLS_BOX; + else if ( pLine[1] == 'a' ) + Type = GLS_BAR; + else assert( 0 ); + } + else if ( *pLine == 'S' ) + { + if ( pLine[2] == 'l' ) + Type = GLS_SEL; + else if ( pLine[2] == 'q' ) + Type = GLS_SEQ; + else assert( 0 ); + } + else if ( *pLine == 'D' ) + Type = GLS_DEL; + else assert( 0 ); + Vec_StrPush( vLines, (char)Type ); + pCounts[Type]++; } - for ( i = 0; i < Vec_IntSize(vObjs); i++ ) + ABC_FREE( pBuffer ); + return vLines; +} +int Gls_ManParseOne( char ** ppLine ) +{ + int Entry; + char * pLine = *ppLine; + while ( *pLine == ' ' ) pLine++; + if ( *pLine == '-' ) + Entry = GLS_NONE; + else if ( *pLine == '0' ) + Entry = 0; + else if ( *pLine == '1' ) + Entry = 1; + else if ( *pLine == 'w' ) + Entry = atoi(++pLine); + else assert( 0 ); + while ( *pLine == '-' || (*pLine >= '0' && *pLine <= '9') ) pLine++; + while ( *pLine == ' ' ) pLine++; + *ppLine = pLine; + return Entry; +} +int Gls_ManParse( FILE * pFile, Gls_Man_t * p ) +{ + char * pLine, * pBuffer = ABC_ALLOC(char, MAX_LINE); + int i, k, Type, iObj, Entry, iItem; word Truth; + for ( i = 0; fgets( pBuffer, MAX_LINE, pFile ) != NULL; i++ ) { - pEntry = Vec_IntEntryP( vStore, Vec_IntEntry(vObjs,i) ); - if ( pEntry[1] != GIG_DELAY ) + pLine = pBuffer; + Type = Vec_StrEntry( p->vLines, i ); + iObj = Gls_ManParseOne( &pLine ); + Vec_StrWriteEntry( p->vTypes, iObj, (char)Type ); + if ( Type == GLS_PI ) + { + Vec_IntPush( p->vOrderPis, iObj ); + Vec_IntWriteEntry( p->vIndexes, iObj, -1 ); + continue; + } + while ( *pLine ) + if ( *pLine++ == '(' ) + break; + Entry = Gls_ManParseOne( &pLine ); + if ( Type == GLS_PO || Type == GLS_BAR || Type == GLS_SEQ || Type == GLS_SEL ) + { + if ( Type == GLS_PO ) + Vec_IntPush( p->vOrderPos, iObj ); + else if ( Type == GLS_BAR ) + Vec_IntPush( p->vOrderLuts, iObj ); + else if ( Type == GLS_SEQ ) + Vec_IntPush( p->vOrderSeqs, iObj ); + else if ( Type == GLS_SEL ) + { + if ( (int)Vec_StrEntry(p->vTypes, Entry) == GLS_DEL ) + { + Vec_Int_t * vOuts = Vec_WecEntry( p->vDelayOuts, Vec_IntEntry(p->vIndexes, Entry) ); + Vec_IntPush( vOuts, iObj ); + } + else if ( (int)Vec_StrEntry(p->vTypes, Entry) == GLS_BAR ) + Vec_IntPush( p->vOrderLuts, iObj ); + else assert( 0 ); + } + Vec_IntWriteEntry( p->vIndexes, iObj, Entry ); continue; - printf( "(%d,%d,%d) ", pEntry[2], Vec_IntEntry(vFanCount, pEntry[0]), pEntry[3+pEntry[2]] ); + } + if ( Type == GLS_LUT4 ) + { + Vec_IntWriteEntry( p->vIndexes, iObj, Vec_IntSize(p->vLut4TTs) ); + Vec_IntPush( p->vLut4s, Entry ); + for ( k = 1; ; k++ ) + { + if ( *pLine != ',' ) break; + pLine++; + Entry = Gls_ManParseOne( &pLine ); + Vec_IntPush( p->vLut4s, Entry ); + } + assert( *pLine == ')' ); + assert( k == 4 ); + pLine++; + while ( *pLine ) + if ( *pLine++ == '[' ) + break; + Abc_TtReadHex( &Truth, pLine ); + Vec_IntPush( p->vLut4TTs, (unsigned)Truth ); + Vec_IntPush( p->vOrderLuts, iObj ); + } + else if ( Type == GLS_LUT6 ) + { + Vec_IntWriteEntry( p->vIndexes, iObj, Vec_WrdSize(p->vLut6TTs) ); + Vec_IntPush( p->vLut6s, Entry ); + for ( k = 1; ; k++ ) + { + if ( *pLine != ',' ) break; + pLine++; + Entry = Gls_ManParseOne( &pLine ); + Vec_IntPush( p->vLut6s, Entry ); + } + assert( *pLine == ')' ); + assert( k == 4 ); + pLine++; + while ( *pLine ) + if ( *pLine++ == '[' ) + break; + Abc_TtReadHex( &Truth, pLine ); + Vec_WrdPush( p->vLut6TTs, Truth ); + Vec_IntPush( p->vOrderLuts, iObj ); + } + else if ( Type == GLS_BOX ) + { + Vec_IntWriteEntry( p->vIndexes, iObj, Vec_IntSize(p->vBoxes)/5 ); + Vec_IntPush( p->vBoxes, Entry ); + for ( k = 1; ; k++ ) + { + if ( *pLine != ',' ) break; + pLine++; + Entry = Gls_ManParseOne( &pLine ); + Vec_IntPush( p->vBoxes, Entry ); + } + assert( *pLine == ')' ); + assert( k == 4 || k == 5 ); + if ( k == 4 ) + Vec_IntPush( p->vBoxes, GLS_NONE ); + Vec_IntPush( p->vOrderBoxes, iObj ); + } + else if ( Type == GLS_DEL ) + { + Vec_Int_t * vIns = Vec_WecPushLevel( p->vDelayIns ); + Vec_Int_t * vOuts = Vec_WecPushLevel( p->vDelayOuts ); + Vec_IntWriteEntry( p->vIndexes, iObj, Vec_IntSize(p->vDelays) ); + Vec_IntPush( vIns, Entry ); + if ( *pLine != ')' ) + { + for ( k = 1; ; k++ ) + { + if ( *pLine != ',' ) break; + pLine++; + Entry = Gls_ManParseOne( &pLine ); + Vec_IntPush( vIns, Entry ); + } + } + assert( *pLine == ')' ); + pLine++; + while ( *pLine ) + if ( *pLine++ == '[' ) + break; + iItem = atoi(pLine); + Vec_IntPush( p->vDelays, iItem ); + Vec_IntPush( p->vOrderDelays, iObj ); + } + else assert( 0 ); } - printf( "\n" ); - Vec_IntFree( vFanCount ); + ABC_FREE( pBuffer ); + return 1; } /**Function************************************************************* @@ -135,59 +376,83 @@ void Gia_ManPrintDelays( Vec_Int_t * vObjs, Vec_Int_t * vStore ) SeeAlso [] ***********************************************************************/ -Gia_Man_t * Gia_ManBuildGig2( Vec_Int_t * vObjs, Vec_Int_t * vStore, char * pFileName ) +Gia_Man_t * Gls_ManConstruct( Gls_Man_t * p, char * pFileName ) { - Gia_Man_t * pNew, * pTemp; - //int * nObjs = Gia_ManGigCount( vObjs, vStore ); - Vec_Int_t * vNets = Vec_IntAlloc( Vec_IntSize(vObjs) ); - Vec_Int_t * vTypes = Vec_IntAlloc( Vec_IntSize(vObjs) ); - Vec_Int_t * vMap; - int i, Type; - // connect net IDs - for ( i = 0; i < Vec_IntSize(vObjs); i++ ) - { - Vec_IntPush( vNets, Vec_IntEntry(vStore, Vec_IntEntry(vObjs,i)) ); - Vec_IntPush( vTypes, Vec_IntEntry(vStore, Vec_IntEntry(vObjs,i) + 1) ); - } - // create mapping for net IDs into GIA IDs - vMap = Vec_IntStartFull( Vec_IntFindMax(vNets) + 1 ); + extern int Kit_TruthToGia( Gia_Man_t * pMan, unsigned * pTruth, int nVars, Vec_Int_t * vMemory, Vec_Int_t * vLeaves, int fHash ); + Gia_Man_t * pGia = NULL; + Vec_Int_t * vMap, * vArray; + Vec_Int_t * vCover = Vec_IntAlloc(0); + Vec_Int_t * vLeaves = Vec_IntAlloc(6); + int k, iObj, iLit, Index; char Type; + // create new manager + pGia = Gia_ManStart( Vec_StrSize(p->vTypes) ); + pGia->pName = Abc_UtilStrsav( pFileName ); + pGia->pSpec = Abc_UtilStrsav( pFileName ); + // create constants + vMap = Vec_IntStartFull( Vec_StrSize(p->vTypes) ); Vec_IntWriteEntry( vMap, 0, 0 ); Vec_IntWriteEntry( vMap, 1, 1 ); - // create new manager - pNew = Gia_ManStart( Vec_IntSize(vObjs) ); - pNew->pName = Abc_UtilStrsav( pFileName ); - pNew->pSpec = Abc_UtilStrsav( pFileName ); // create primary inputs - for ( i = 0; i < Vec_IntSize(vObjs); i++ ) - if ( Vec_IntEntry(vTypes, i) == GIG_PI ) - Vec_IntWriteEntry( vMap, Vec_IntEntry(vNets, i), Gia_ManAppendCi(pNew) ); + Vec_IntForEachEntry( p->vOrderPis, iObj, k ) + Vec_IntWriteEntry( vMap, iObj, Gia_ManAppendCi(pGia) ); // create box outputs - for ( i = 0; i < Vec_IntSize(vObjs); i++ ) - if ( Vec_IntEntry(vTypes, i) == GIG_BOX ) - Vec_IntWriteEntry( vMap, Vec_IntEntry(vNets, i), Gia_ManAppendCi(pNew) ); - // create internal nodes - Gia_ManHashAlloc( pNew ); - for ( i = 0; i < Vec_IntSize(vObjs); i++ ) + Vec_IntForEachEntry( p->vOrderBoxes, iObj, k ) + Vec_IntWriteEntry( vMap, iObj, Gia_ManAppendCi(pGia) ); + // create delay outputs + Vec_IntForEachEntry( p->vOrderDelays, iObj, Index ) { - Type = Vec_IntEntry(vTypes, i); - if ( Type != GIG_LUT && Type != GIG_DELAY && Type != GIG_BAR ) - continue; - + assert( Index == Vec_IntEntry(p->vIndexes, iObj) ); + vArray = Vec_WecEntry(p->vDelayOuts, Index); + if ( Vec_IntSize(vArray) == 0 ) + Vec_IntWriteEntry( vMap, iObj, Gia_ManAppendCi(pGia) ); + else + Vec_IntForEachEntry( vArray, iObj, k ) + Vec_IntWriteEntry( vMap, iObj, Gia_ManAppendCi(pGia) ); + } + // construct LUTs + Vec_IntForEachEntry( p->vOrderLuts, iObj, Index ) + { + Type = Vec_StrEntry( p->vTypes, iObj ); + if ( Type == GLS_LUT4 || Type == GLS_LUT6 ) + { + int Limit = Type == GLS_LUT4 ? 4 : 6; + int Index = Vec_IntEntry(p->vIndexes, iObj); + int * pFanins = Type == GLS_LUT4 ? Vec_IntEntryP(p->vLut4s, 4*Index) : Vec_IntEntryP(p->vLut6s, 6*Index); + word Truth = Type == GLS_LUT4 ? (word)Vec_IntEntry(p->vLut4TTs, Index) : Vec_WrdEntry(p->vLut6TTs, Index); + Vec_IntClear( vLeaves ); + for ( k = 0; k < Limit; k++ ) + Vec_IntPush( vLeaves, pFanins[k] == GLS_NONE ? 0 : Vec_IntEntry(vMap, pFanins[k]) ); + iLit = Kit_TruthToGia( pGia, (unsigned *)&Truth, Vec_IntSize(vLeaves), vCover, vLeaves, 0 ); + Vec_IntWriteEntry( vMap, iObj, iLit ); + } + else if ( Type == GLS_BAR || Type == GLS_SEL ) + { + iLit = Vec_IntEntry( vMap, Vec_IntEntry(p->vIndexes, iObj) ); + Vec_IntWriteEntry( vMap, iObj, iLit ); + } + } + // delay inputs + Vec_IntForEachEntry( p->vOrderDelays, iObj, Index ) + { + vArray = Vec_WecEntry(p->vDelayIns, Index); + assert( Vec_IntSize(vArray) > 0 ); + Vec_IntForEachEntry( vArray, iObj, k ) + Gia_ManAppendCo( pGia, Vec_IntEntry(vMap, iObj) ); } + // create primary outputs + Vec_IntForEachEntry( p->vOrderPos, iObj, k ) + Gia_ManAppendCo( pGia, Vec_IntEntry(vMap, Vec_IntEntry(p->vIndexes, iObj)) ); + // create sequential nodes + Vec_IntForEachEntry( p->vOrderSeqs, iObj, k ) + Gia_ManAppendCo( pGia, Vec_IntEntry(vMap, Vec_IntEntry(p->vIndexes, iObj)) ); Vec_IntFree( vMap ); - Vec_IntFree( vNets ); - Vec_IntFree( vTypes ); - // rehash - pNew = Gia_ManCleanup( pTemp = pNew ); - Gia_ManStop( pTemp ); - return pNew; -} -Gia_Man_t * Gia_ManBuildGig( Vec_Int_t * vObjs, Vec_Int_t * vStore, char * pFileName ) -{ - printf( "Parsed %d objects and %d tokens.\n", Vec_IntSize(vObjs), Vec_IntSize(vStore) ); - Gia_ManGigPrint( Gia_ManGigCount(vObjs, vStore) ); - Gia_ManPrintDelays( vObjs, vStore ); - return NULL; + Vec_IntFree( vCover ); + Vec_IntFree( vLeaves ); + // print delay boxes +// for ( k = 0; k < Vec_IntSize(p->vDelays); k++ ) +// printf( "%d:%d ", Vec_IntSize(Vec_WecEntry(p->vDelayIns, k)), Vec_IntSize(Vec_WecEntry(p->vDelayOuts, k)) ); +// printf( "\n" ); + return pGia; } /**Function************************************************************* @@ -203,93 +468,32 @@ Gia_Man_t * Gia_ManBuildGig( Vec_Int_t * vObjs, Vec_Int_t * vStore, char * pFile ***********************************************************************/ Gia_Man_t * Gia_ManReadGig( char * pFileName ) { - Gia_Man_t * pNew; - int Type, Offset, fEndOfLine, Digit, nObjs; - char * pChars = " w(-,)]\r\t"; - char * pBuffer = Extra_FileReadContents( pFileName ); - char * pStart = pBuffer, * pToken; - Vec_Int_t * vObjs, * vStore; - if ( pBuffer == NULL ) - printf( "Cannot open input file %s\n", pFileName ); - // count objects - for ( nObjs = 0, pToken = pBuffer; *pToken; pToken++ ) - nObjs += (int)(*pToken == '\n'); - // read objects - vObjs = Vec_IntAlloc( nObjs ); - vStore = Vec_IntAlloc( 10*nObjs ); - while ( 1 ) + abctime clk = Abc_Clock(); + Gls_Man_t * p = NULL; + Gia_Man_t * pGia = NULL; + Vec_Str_t * vLines; + int i, pCounts[GLS_FINAL]; + FILE * pFile = fopen( pFileName, "rb" ); + if ( pFile == NULL ) { - // read net ID - pToken = strtok( pStart, pChars ); - pStart = NULL; - if ( pToken == NULL ) - break; - // start new object - Vec_IntPush( vObjs, Vec_IntSize(vStore) ); - // save net ID - assert( pToken[0] >= '0' && pToken[0] <= '9' ); - Vec_IntPush( vStore, atoi(pToken) ); - // read equal - pToken = strtok( pStart, pChars ); - assert( pToken[0] == '=' ); - // read type - pToken = strtok( pStart, pChars ); - fEndOfLine = 0; - if ( pToken[strlen(pToken)-1] == '\n' ) - { - pToken[strlen(pToken)-1] = 0; - fEndOfLine = 1; - } - for ( Type = GIG_RESET; Type < GIG_UNUSED; Type++ ) - if ( !strcmp(pToken, s_GigNames[Type]) ) - break; - assert( Type < GIG_UNUSED ); - Vec_IntPush( vStore, Type ); - if ( fEndOfLine ) - continue; - // read fanins - Offset = Vec_IntSize(vStore); - Vec_IntPush( vStore, 0 ); - while ( 1 ) - { - pToken = strtok( pStart, pChars ); - if ( pToken == NULL || pToken[0] == '\n' || pToken[0] == '[' ) - break; - assert( pToken[0] >= '0' && pToken[0] <= '9' ); - Vec_IntPush( vStore, atoi(pToken) ); - Vec_IntAddToEntry( vStore, Offset, 1 ); - } - assert( pToken != NULL ); - if ( pToken[0] == '\n' ) - continue; - assert( pToken[0] == '[' ); - // read attribute - pToken++; - if ( Type == GIG_LUT ) - { - assert( strlen(pToken) == 4 ); - Digit = Abc_TtReadHexDigit(pToken[0]); - Digit |= Abc_TtReadHexDigit(pToken[1]) << 4; - Digit |= Abc_TtReadHexDigit(pToken[2]) << 8; - Digit |= Abc_TtReadHexDigit(pToken[3]) << 12; - Vec_IntPush( vStore, Digit ); - } - else - { - assert( Type == GIG_DELAY ); - Vec_IntPush( vStore, atoi(pToken) ); - } - // read end of line - pToken = strtok( pStart, pChars ); - assert( pToken[0] == '\n' ); + printf( "Cannot read file \"%s\".\n", pFileName ); + return NULL; } - ABC_FREE( pBuffer ); - // create AIG - pNew = Gia_ManBuildGig( vObjs, vStore, pFileName ); - // cleanup - Vec_IntFree( vObjs ); - Vec_IntFree( vStore ); - return pNew; + vLines = Gls_ManCount( pFile, pCounts ); + rewind( pFile ); + // statistics + for ( i = 0; i < GLS_FINAL; i++ ) + if ( pCounts[i] ) + printf( "%s=%d ", s_Strs[i], pCounts[i] ); + Abc_PrintTime( 1, "Time", Abc_Clock() - clk ); + // collect data and derive AIG + p = Gls_ManAlloc( vLines, pCounts ); + if ( Gls_ManParse( pFile, p ) ) + pGia = Gls_ManConstruct( p, pFileName ); + Gls_ManStop( p ); + fclose( pFile ); + //printf( "\n" ); + return pGia; } //////////////////////////////////////////////////////////////////////// -- cgit v1.2.3