/src/aig/gia/giaAiger.c
C | 1479 lines | 1120 code | 66 blank | 293 comment | 372 complexity | d2adb49cdb68a957ab13a04502ec3a4b MD5 | raw file
Possible License(s): BSD-3-Clause
Large files files are truncated, but you can click here to view the full file
- /**CFile****************************************************************
- FileName [giaAiger.c]
- SystemName [ABC: Logic synthesis and verification system.]
- PackageName [Scalable AIG package.]
- Synopsis [Procedures to read/write binary AIGER format developed by
- Armin Biere, Johannes Kepler University (http://fmv.jku.at/)]
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
- Date [Ver. 1.0. Started - June 20, 2005.]
- Revision [$Id: giaAiger.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
- ***********************************************************************/
- #include "gia.h"
- #include "misc/tim/tim.h"
- #include "base/main/main.h"
- ABC_NAMESPACE_IMPL_START
-
- #define XAIG_VERBOSE 0
- ////////////////////////////////////////////////////////////////////////
- /// DECLARATIONS ///
- ////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////
- /// FUNCTION DEFINITIONS ///
- ////////////////////////////////////////////////////////////////////////
- /**Function*************************************************************
- Synopsis []
- Description []
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- void Gia_FileFixName( char * pFileName )
- {
- char * pName;
- for ( pName = pFileName; *pName; pName++ )
- if ( *pName == '>' )
- *pName = '\\';
- }
- char * Gia_FileNameGeneric( char * FileName )
- {
- char * pDot, * pRes;
- pRes = Abc_UtilStrsav( FileName );
- if ( (pDot = strrchr( pRes, '.' )) )
- *pDot = 0;
- return pRes;
- }
- int Gia_FileSize( char * pFileName )
- {
- FILE * pFile;
- int nFileSize;
- pFile = fopen( pFileName, "r" );
- if ( pFile == NULL )
- {
- printf( "Gia_FileSize(): The file is unavailable (absent or open).\n" );
- return 0;
- }
- fseek( pFile, 0, SEEK_END );
- nFileSize = ftell( pFile );
- fclose( pFile );
- return nFileSize;
- }
- void Gia_FileWriteBufferSize( FILE * pFile, int nSize )
- {
- unsigned char Buffer[5];
- Gia_AigerWriteInt( Buffer, nSize );
- fwrite( Buffer, 1, 4, pFile );
- }
-
- /**Function*************************************************************
-
- Synopsis [Create the array of literals to be written.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
- ***********************************************************************/
- Vec_Int_t * Gia_AigerCollectLiterals( Gia_Man_t * p )
- {
- Vec_Int_t * vLits;
- Gia_Obj_t * pObj;
- int i;
- vLits = Vec_IntAlloc( Gia_ManPoNum(p) );
- Gia_ManForEachRi( p, pObj, i )
- Vec_IntPush( vLits, Gia_ObjFaninLit0p(p, pObj) );
- Gia_ManForEachPo( p, pObj, i )
- Vec_IntPush( vLits, Gia_ObjFaninLit0p(p, pObj) );
- return vLits;
- }
- Vec_Int_t * Gia_AigerReadLiterals( unsigned char ** ppPos, int nEntries )
- {
- Vec_Int_t * vLits;
- int Lit, LitPrev, Diff, i;
- vLits = Vec_IntAlloc( nEntries );
- LitPrev = Gia_AigerReadUnsigned( ppPos );
- Vec_IntPush( vLits, LitPrev );
- for ( i = 1; i < nEntries; i++ )
- {
- // Diff = Lit - LitPrev;
- // Diff = (Lit < LitPrev)? -Diff : Diff;
- // Diff = ((2 * Diff) << 1) | (int)(Lit < LitPrev);
- Diff = Gia_AigerReadUnsigned( ppPos );
- Diff = (Diff & 1)? -(Diff >> 1) : Diff >> 1;
- Lit = Diff + LitPrev;
- Vec_IntPush( vLits, Lit );
- LitPrev = Lit;
- }
- return vLits;
- }
- Vec_Str_t * Gia_AigerWriteLiterals( Vec_Int_t * vLits )
- {
- Vec_Str_t * vBinary;
- int Pos = 0, Lit, LitPrev, Diff, i;
- vBinary = Vec_StrAlloc( 2 * Vec_IntSize(vLits) );
- LitPrev = Vec_IntEntry( vLits, 0 );
- Pos = Gia_AigerWriteUnsignedBuffer( (unsigned char *)Vec_StrArray(vBinary), Pos, LitPrev );
- Vec_IntForEachEntryStart( vLits, Lit, i, 1 )
- {
- Diff = Lit - LitPrev;
- Diff = (Lit < LitPrev)? -Diff : Diff;
- Diff = (Diff << 1) | (int)(Lit < LitPrev);
- Pos = Gia_AigerWriteUnsignedBuffer( (unsigned char *)Vec_StrArray(vBinary), Pos, Diff );
- LitPrev = Lit;
- if ( Pos + 10 > vBinary->nCap )
- Vec_StrGrow( vBinary, vBinary->nCap+1 );
- }
- vBinary->nSize = Pos;
- /*
- // verify
- {
- extern Vec_Int_t * Gia_AigerReadLiterals( char ** ppPos, int nEntries );
- char * pPos = Vec_StrArray( vBinary );
- Vec_Int_t * vTemp = Gia_AigerReadLiterals( &pPos, Vec_IntSize(vLits) );
- for ( i = 0; i < Vec_IntSize(vLits); i++ )
- {
- int Entry1 = Vec_IntEntry(vLits,i);
- int Entry2 = Vec_IntEntry(vTemp,i);
- assert( Entry1 == Entry2 );
- }
- Vec_IntFree( vTemp );
- }
- */
- return vBinary;
- }
- /**Function*************************************************************
- Synopsis [Reads the AIG in the binary AIGER format.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- Gia_Man_t * Gia_AigerReadFromMemory( char * pContents, int nFileSize, int fGiaSimple, int fSkipStrash, int fCheck )
- {
- Gia_Man_t * pNew, * pTemp;
- Vec_Int_t * vLits = NULL, * vPoTypes = NULL;
- Vec_Int_t * vNodes, * vDrivers, * vInits = NULL;
- int iObj, iNode0, iNode1, fHieOnly = 0;
- int nTotal, nInputs, nOutputs, nLatches, nAnds, i;
- int nBad = 0, nConstr = 0, nJust = 0, nFair = 0;
- unsigned char * pDrivers, * pSymbols, * pCur;
- unsigned uLit0, uLit1, uLit;
- // read the parameters (M I L O A + B C J F)
- pCur = (unsigned char *)pContents; while ( *pCur != ' ' ) pCur++; pCur++;
- // read the number of objects
- nTotal = atoi( (const char *)pCur ); while ( *pCur != ' ' ) pCur++; pCur++;
- // read the number of inputs
- nInputs = atoi( (const char *)pCur ); while ( *pCur != ' ' ) pCur++; pCur++;
- // read the number of latches
- nLatches = atoi( (const char *)pCur ); while ( *pCur != ' ' ) pCur++; pCur++;
- // read the number of outputs
- nOutputs = atoi( (const char *)pCur ); while ( *pCur != ' ' ) pCur++; pCur++;
- // read the number of nodes
- nAnds = atoi( (const char *)pCur ); while ( *pCur != ' ' && *pCur != '\n' ) pCur++;
- if ( *pCur == ' ' )
- {
- // assert( nOutputs == 0 );
- // read the number of properties
- pCur++;
- nBad = atoi( (const char *)pCur ); while ( *pCur != ' ' && *pCur != '\n' ) pCur++;
- nOutputs += nBad;
- }
- if ( *pCur == ' ' )
- {
- // read the number of properties
- pCur++;
- nConstr = atoi( (const char *)pCur ); while ( *pCur != ' ' && *pCur != '\n' ) pCur++;
- nOutputs += nConstr;
- }
- if ( *pCur == ' ' )
- {
- // read the number of properties
- pCur++;
- nJust = atoi( (const char *)pCur ); while ( *pCur != ' ' && *pCur != '\n' ) pCur++;
- nOutputs += nJust;
- }
- if ( *pCur == ' ' )
- {
- // read the number of properties
- pCur++;
- nFair = atoi( (const char *)pCur ); while ( *pCur != ' ' && *pCur != '\n' ) pCur++;
- nOutputs += nFair;
- }
- if ( *pCur != '\n' )
- {
- fprintf( stdout, "The parameter line is in a wrong format.\n" );
- return NULL;
- }
- pCur++;
- // check the parameters
- if ( nTotal != nInputs + nLatches + nAnds )
- {
- fprintf( stdout, "The number of objects does not match.\n" );
- return NULL;
- }
- if ( nJust || nFair )
- {
- fprintf( stdout, "Reading AIGER files with liveness properties is currently not supported.\n" );
- return NULL;
- }
- if ( nConstr )
- {
- if ( nConstr == 1 )
- fprintf( stdout, "Warning: The last output is interpreted as a constraint.\n" );
- else
- fprintf( stdout, "Warning: The last %d outputs are interpreted as constraints.\n", nConstr );
- }
- // allocate the empty AIG
- pNew = Gia_ManStart( nTotal + nLatches + nOutputs + 1 );
- pNew->nConstrs = nConstr;
- pNew->fGiaSimple = fGiaSimple;
- // prepare the array of nodes
- vNodes = Vec_IntAlloc( 1 + nTotal );
- Vec_IntPush( vNodes, 0 );
- // create the PIs
- for ( i = 0; i < nInputs + nLatches; i++ )
- {
- iObj = Gia_ManAppendCi(pNew);
- Vec_IntPush( vNodes, iObj );
- }
- // remember the beginning of latch/PO literals
- pDrivers = pCur;
- if ( pContents[3] == ' ' ) // standard AIGER
- {
- // scroll to the beginning of the binary data
- for ( i = 0; i < nLatches + nOutputs; )
- if ( *pCur++ == '\n' )
- i++;
- }
- else // modified AIGER
- {
- vLits = Gia_AigerReadLiterals( &pCur, nLatches + nOutputs );
- }
- // create the AND gates
- if ( !fGiaSimple && !fSkipStrash )
- Gia_ManHashAlloc( pNew );
- for ( i = 0; i < nAnds; i++ )
- {
- uLit = ((i + 1 + nInputs + nLatches) << 1);
- uLit1 = uLit - Gia_AigerReadUnsigned( &pCur );
- uLit0 = uLit1 - Gia_AigerReadUnsigned( &pCur );
- // assert( uLit1 > uLit0 );
- iNode0 = Abc_LitNotCond( Vec_IntEntry(vNodes, uLit0 >> 1), uLit0 & 1 );
- iNode1 = Abc_LitNotCond( Vec_IntEntry(vNodes, uLit1 >> 1), uLit1 & 1 );
- assert( Vec_IntSize(vNodes) == i + 1 + nInputs + nLatches );
- if ( !fGiaSimple && fSkipStrash )
- {
- if ( iNode0 == iNode1 )
- Vec_IntPush( vNodes, Gia_ManAppendBuf(pNew, iNode0) );
- else
- Vec_IntPush( vNodes, Gia_ManAppendAnd(pNew, iNode0, iNode1) );
- }
- else
- Vec_IntPush( vNodes, Gia_ManHashAnd(pNew, iNode0, iNode1) );
- }
- if ( !fGiaSimple && !fSkipStrash )
- Gia_ManHashStop( pNew );
- // remember the place where symbols begin
- pSymbols = pCur;
- // read the latch driver literals
- vDrivers = Vec_IntAlloc( nLatches + nOutputs );
- if ( pContents[3] == ' ' ) // standard AIGER
- {
- vInits = Vec_IntAlloc( nLatches );
- pCur = pDrivers;
- for ( i = 0; i < nLatches; i++ )
- {
- uLit0 = atoi( (char *)pCur );
- while ( *pCur != ' ' && *pCur != '\n' )
- pCur++;
- if ( *pCur == ' ' )
- {
- pCur++;
- Vec_IntPush( vInits, atoi( (char *)pCur ) );
- while ( *pCur++ != '\n' );
- }
- else
- {
- pCur++;
- Vec_IntPush( vInits, 0 );
- }
- iNode0 = Abc_LitNotCond( Vec_IntEntry(vNodes, uLit0 >> 1), (uLit0 & 1) );
- Vec_IntPush( vDrivers, iNode0 );
- }
- // read the PO driver literals
- for ( i = 0; i < nOutputs; i++ )
- {
- uLit0 = atoi( (char *)pCur ); while ( *pCur++ != '\n' );
- iNode0 = Abc_LitNotCond( Vec_IntEntry(vNodes, uLit0 >> 1), (uLit0 & 1) );
- Vec_IntPush( vDrivers, iNode0 );
- }
- }
- else
- {
- // read the latch driver literals
- for ( i = 0; i < nLatches; i++ )
- {
- uLit0 = Vec_IntEntry( vLits, i );
- iNode0 = Abc_LitNotCond( Vec_IntEntry(vNodes, uLit0 >> 1), (uLit0 & 1) );
- Vec_IntPush( vDrivers, iNode0 );
- }
- // read the PO driver literals
- for ( i = 0; i < nOutputs; i++ )
- {
- uLit0 = Vec_IntEntry( vLits, i+nLatches );
- iNode0 = Abc_LitNotCond( Vec_IntEntry(vNodes, uLit0 >> 1), (uLit0 & 1) );
- Vec_IntPush( vDrivers, iNode0 );
- }
- Vec_IntFree( vLits );
- }
- // create the POs
- for ( i = 0; i < nOutputs; i++ )
- Gia_ManAppendCo( pNew, Vec_IntEntry(vDrivers, nLatches + i) );
- for ( i = 0; i < nLatches; i++ )
- Gia_ManAppendCo( pNew, Vec_IntEntry(vDrivers, i) );
- Vec_IntFree( vDrivers );
- // create the latches
- Gia_ManSetRegNum( pNew, nLatches );
-
- // read signal names if they are of the special type
- pCur = pSymbols;
- if ( pCur < (unsigned char *)pContents + nFileSize && *pCur != 'c' )
- {
- int fBreakUsed = 0;
- unsigned char * pCurOld = pCur;
- pNew->vUserPiIds = Vec_IntStartFull( nInputs );
- pNew->vUserPoIds = Vec_IntStartFull( nOutputs );
- pNew->vUserFfIds = Vec_IntStartFull( nLatches );
- while ( pCur < (unsigned char *)pContents + nFileSize && *pCur != 'c' )
- {
- int iTerm;
- char * pType = (char *)pCur;
- // check terminal type
- if ( *pCur != 'i' && *pCur != 'o' && *pCur != 'l' )
- {
- // fprintf( stdout, "Wrong terminal type.\n" );
- fBreakUsed = 1;
- break;
- }
- // get terminal number
- iTerm = atoi( (char *)++pCur ); while ( *pCur++ != ' ' );
- // skip spaces
- while ( *pCur == ' ' )
- pCur++;
- // decode the user numbers:
- // flops are named: @l<num>
- // PIs are named: @i<num>
- // POs are named: @o<num>
- if ( *pCur++ != '@' )
- {
- fBreakUsed = 1;
- break;
- }
- if ( *pCur == 'i' && *pType == 'i' )
- Vec_IntWriteEntry( pNew->vUserPiIds, iTerm, atoi((char *)pCur+1) );
- else if ( *pCur == 'o' && *pType == 'o' )
- Vec_IntWriteEntry( pNew->vUserPoIds, iTerm, atoi((char *)pCur+1) );
- else if ( *pCur == 'l' && *pType == 'l' )
- Vec_IntWriteEntry( pNew->vUserFfIds, iTerm, atoi((char *)pCur+1) );
- else
- {
- fprintf( stdout, "Wrong name format.\n" );
- fBreakUsed = 1;
- break;
- }
- // skip digits
- while ( *pCur++ != '\n' );
- }
- // in case of abnormal termination, remove the arrays
- if ( fBreakUsed )
- {
- unsigned char * pName;
- int Entry, nInvars, nConstr, iTerm;
-
- Vec_Int_t * vPoNames = Vec_IntStartFull( nOutputs );
-
- Vec_IntFreeP( &pNew->vUserPiIds );
- Vec_IntFreeP( &pNew->vUserPoIds );
- Vec_IntFreeP( &pNew->vUserFfIds );
-
- // try to figure out signal names
- fBreakUsed = 0;
- pCur = (unsigned char *)pCurOld;
- while ( pCur < (unsigned char *)pContents + nFileSize && *pCur != 'c' )
- {
- // get the terminal type
- if ( *pCur == 'i' || *pCur == 'l' )
- {
- // skip till the end of the line
- while ( *pCur++ != '\n' );
- *(pCur-1) = 0;
- continue;
- }
- if ( *pCur != 'o' )
- {
- // fprintf( stdout, "Wrong terminal type.\n" );
- fBreakUsed = 1;
- break;
- }
- // get the terminal number
- iTerm = atoi( (char *)++pCur ); while ( *pCur++ != ' ' );
- // get the node
- if ( iTerm < 0 || iTerm >= nOutputs )
- {
- fprintf( stdout, "The output number (%d) is out of range.\n", iTerm );
- fBreakUsed = 1;
- break;
- }
- if ( Vec_IntEntry(vPoNames, iTerm) != ~0 )
- {
- fprintf( stdout, "The output number (%d) is listed twice.\n", iTerm );
- fBreakUsed = 1;
- break;
- }
-
- // get the name
- pName = pCur; while ( *pCur++ != '\n' );
- *(pCur-1) = 0;
- // assign the name
- Vec_IntWriteEntry( vPoNames, iTerm, pName - (unsigned char *)pContents );
- }
-
- // check that all names are assigned
- if ( !fBreakUsed )
- {
- nInvars = nConstr = 0;
- vPoTypes = Vec_IntStart( Gia_ManPoNum(pNew) );
- Vec_IntForEachEntry( vPoNames, Entry, i )
- {
- if ( Entry == ~0 )
- continue;
- if ( strncmp( pContents+Entry, "constraint:", 11 ) == 0 )
- {
- Vec_IntWriteEntry( vPoTypes, i, 1 );
- nConstr++;
- }
- if ( strncmp( pContents+Entry, "invariant:", 10 ) == 0 )
- {
- Vec_IntWriteEntry( vPoTypes, i, 2 );
- nInvars++;
- }
- }
- if ( nConstr )
- fprintf( stdout, "Recognized and added %d constraints.\n", nConstr );
- if ( nInvars )
- fprintf( stdout, "Recognized and skipped %d invariants.\n", nInvars );
- if ( nConstr == 0 && nInvars == 0 )
- Vec_IntFreeP( &vPoTypes );
- }
- Vec_IntFree( vPoNames );
- }
- }
- // check if there are other types of information to read
- if ( pCur + 1 < (unsigned char *)pContents + nFileSize && *pCur == 'c' )
- {
- int fVerbose = XAIG_VERBOSE;
- Vec_Str_t * vStr;
- unsigned char * pCurTemp;
- pCur++;
- // skip new line if present
- // if ( *pCur == '\n' )
- // pCur++;
- while ( pCur < (unsigned char *)pContents + nFileSize )
- {
- // read extra AIG
- if ( *pCur == 'a' )
- {
- pCur++;
- vStr = Vec_StrStart( Gia_AigerReadInt(pCur) ); pCur += 4;
- memcpy( Vec_StrArray(vStr), pCur, Vec_StrSize(vStr) );
- pCur += Vec_StrSize(vStr);
- pNew->pAigExtra = Gia_AigerReadFromMemory( Vec_StrArray(vStr), Vec_StrSize(vStr), 0, 0, 0 );
- Vec_StrFree( vStr );
- if ( fVerbose ) printf( "Finished reading extension \"a\".\n" );
- }
- // read number of constraints
- else if ( *pCur == 'c' )
- {
- pCur++;
- assert( Gia_AigerReadInt(pCur) == 4 ); pCur += 4;
- pNew->nConstrs = Gia_AigerReadInt( pCur ); pCur += 4;
- if ( fVerbose ) printf( "Finished reading extension \"c\".\n" );
- }
- // read delay information
- else if ( *pCur == 'd' )
- {
- pCur++;
- assert( Gia_AigerReadInt(pCur) == 4 ); pCur += 4;
- pNew->nAnd2Delay = Gia_AigerReadInt(pCur); pCur += 4;
- if ( fVerbose ) printf( "Finished reading extension \"d\".\n" );
- }
- else if ( *pCur == 'i' )
- {
- pCur++;
- nInputs = Gia_AigerReadInt(pCur)/4; pCur += 4;
- pNew->vInArrs = Vec_FltStart( nInputs );
- memcpy( Vec_FltArray(pNew->vInArrs), pCur, 4*nInputs ); pCur += 4*nInputs;
- if ( fVerbose ) printf( "Finished reading extension \"i\".\n" );
- }
- else if ( *pCur == 'o' )
- {
- pCur++;
- nOutputs = Gia_AigerReadInt(pCur)/4; pCur += 4;
- pNew->vOutReqs = Vec_FltStart( nOutputs );
- memcpy( Vec_FltArray(pNew->vOutReqs), pCur, 4*nOutputs ); pCur += 4*nOutputs;
- if ( fVerbose ) printf( "Finished reading extension \"o\".\n" );
- }
- // read equivalence classes
- else if ( *pCur == 'e' )
- {
- extern Gia_Rpr_t * Gia_AigerReadEquivClasses( unsigned char ** ppPos, int nSize );
- pCur++;
- pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4; pCur += 4;
- pNew->pReprs = Gia_AigerReadEquivClasses( &pCur, Gia_ManObjNum(pNew) );
- pNew->pNexts = Gia_ManDeriveNexts( pNew );
- assert( pCur == pCurTemp );
- if ( fVerbose ) printf( "Finished reading extension \"e\".\n" );
- }
- // read flop classes
- else if ( *pCur == 'f' )
- {
- pCur++;
- assert( Gia_AigerReadInt(pCur) == 4*Gia_ManRegNum(pNew) ); pCur += 4;
- pNew->vFlopClasses = Vec_IntStart( Gia_ManRegNum(pNew) );
- memcpy( Vec_IntArray(pNew->vFlopClasses), pCur, 4*Gia_ManRegNum(pNew) ); pCur += 4*Gia_ManRegNum(pNew);
- if ( fVerbose ) printf( "Finished reading extension \"f\".\n" );
- }
- // read gate classes
- else if ( *pCur == 'g' )
- {
- pCur++;
- assert( Gia_AigerReadInt(pCur) == 4*Gia_ManObjNum(pNew) ); pCur += 4;
- pNew->vGateClasses = Vec_IntStart( Gia_ManObjNum(pNew) );
- memcpy( Vec_IntArray(pNew->vGateClasses), pCur, 4*Gia_ManObjNum(pNew) ); pCur += 4*Gia_ManObjNum(pNew);
- if ( fVerbose ) printf( "Finished reading extension \"g\".\n" );
- }
- // read hierarchy information
- else if ( *pCur == 'h' )
- {
- pCur++;
- vStr = Vec_StrStart( Gia_AigerReadInt(pCur) ); pCur += 4;
- memcpy( Vec_StrArray(vStr), pCur, Vec_StrSize(vStr) );
- pCur += Vec_StrSize(vStr);
- pNew->pManTime = Tim_ManLoad( vStr, 1 );
- Vec_StrFree( vStr );
- fHieOnly = 1;
- if ( fVerbose ) printf( "Finished reading extension \"h\".\n" );
- }
- // read packing
- else if ( *pCur == 'k' )
- {
- extern Vec_Int_t * Gia_AigerReadPacking( unsigned char ** ppPos, int nSize );
- int nSize;
- pCur++;
- nSize = Gia_AigerReadInt(pCur);
- pCurTemp = pCur + nSize + 4; pCur += 4;
- pNew->vPacking = Gia_AigerReadPacking( &pCur, nSize );
- assert( pCur == pCurTemp );
- if ( fVerbose ) printf( "Finished reading extension \"k\".\n" );
- }
- // read mapping
- else if ( *pCur == 'm' )
- {
- extern int * Gia_AigerReadMapping( unsigned char ** ppPos, int nSize );
- extern int * Gia_AigerReadMappingSimple( unsigned char ** ppPos, int nSize );
- extern Vec_Int_t * Gia_AigerReadMappingDoc( unsigned char ** ppPos, int nObjs );
- int nSize;
- pCur++;
- nSize = Gia_AigerReadInt(pCur);
- pCurTemp = pCur + nSize + 4; pCur += 4;
- pNew->vMapping = Gia_AigerReadMappingDoc( &pCur, Gia_ManObjNum(pNew) );
- assert( pCur == pCurTemp );
- if ( fVerbose ) printf( "Finished reading extension \"m\".\n" );
- }
- // read model name
- else if ( *pCur == 'n' )
- {
- pCur++;
- if ( (*pCur >= 'a' && *pCur <= 'z') || (*pCur >= 'A' && *pCur <= 'Z') || (*pCur >= '0' && *pCur <= '9') )
- {
- pNew->pName = Abc_UtilStrsav( (char *)pCur ); pCur += strlen(pNew->pName) + 1;
- }
- else
- {
- pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4; pCur += 4;
- ABC_FREE( pNew->pName );
- pNew->pName = Abc_UtilStrsav( (char *)pCur ); pCur += strlen(pNew->pName) + 1;
- assert( pCur == pCurTemp );
- }
- }
- // read placement
- else if ( *pCur == 'p' )
- {
- Gia_Plc_t * pPlacement;
- pCur++;
- pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4; pCur += 4;
- pPlacement = ABC_ALLOC( Gia_Plc_t, Gia_ManObjNum(pNew) );
- memcpy( pPlacement, pCur, 4*Gia_ManObjNum(pNew) ); pCur += 4*Gia_ManObjNum(pNew);
- assert( pCur == pCurTemp );
- pNew->pPlacement = pPlacement;
- if ( fVerbose ) printf( "Finished reading extension \"p\".\n" );
- }
- // read register classes
- else if ( *pCur == 'r' )
- {
- int i, nRegs;
- pCur++;
- pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4; pCur += 4;
- nRegs = Gia_AigerReadInt(pCur); pCur += 4;
- //nRegs = (pCurTemp - pCur)/4;
- pNew->vRegClasses = Vec_IntAlloc( nRegs );
- for ( i = 0; i < nRegs; i++ )
- Vec_IntPush( pNew->vRegClasses, Gia_AigerReadInt(pCur) ), pCur += 4;
- assert( pCur == pCurTemp );
- if ( fVerbose ) printf( "Finished reading extension \"r\".\n" );
- }
- // read register inits
- else if ( *pCur == 's' )
- {
- int i, nRegs;
- pCur++;
- pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4; pCur += 4;
- nRegs = Gia_AigerReadInt(pCur); pCur += 4;
- pNew->vRegInits = Vec_IntAlloc( nRegs );
- for ( i = 0; i < nRegs; i++ )
- Vec_IntPush( pNew->vRegInits, Gia_AigerReadInt(pCur) ), pCur += 4;
- assert( pCur == pCurTemp );
- if ( fVerbose ) printf( "Finished reading extension \"s\".\n" );
- }
- // read configuration data
- else if ( *pCur == 'b' )
- {
- int nSize;
- pCur++;
- nSize = Gia_AigerReadInt(pCur);
- pCurTemp = pCur + nSize + 4; pCur += 4;
- pNew->pCellStr = Abc_UtilStrsav( (char*)pCur ); pCur += strlen((char*)pCur) + 1;
- nSize = nSize - strlen(pNew->pCellStr) - 1;
- assert( nSize % 4 == 0 );
- pNew->vConfigs = Vec_IntAlloc(nSize / 4);
- // memcpy(Vec_IntArray(pNew->vConfigs), pCur, nSize); pCur += nSize;
- for ( i = 0; i < nSize / 4; i++ )
- Vec_IntPush( pNew->vConfigs, Gia_AigerReadInt(pCur) ), pCur += 4;
- assert( pCur == pCurTemp );
- if ( fVerbose ) printf( "Finished reading extension \"b\".\n" );
- }
- // read choices
- else if ( *pCur == 'q' )
- {
- int i, nPairs, iRepr, iNode;
- assert( !Gia_ManHasChoices(pNew) );
- pNew->pSibls = ABC_CALLOC( int, Gia_ManObjNum(pNew) );
- pCur++;
- pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4; pCur += 4;
- nPairs = Gia_AigerReadInt(pCur); pCur += 4;
- for ( i = 0; i < nPairs; i++ )
- {
- iRepr = Gia_AigerReadInt(pCur); pCur += 4;
- iNode = Gia_AigerReadInt(pCur); pCur += 4;
- pNew->pSibls[iRepr] = iNode;
- assert( iRepr > iNode );
- }
- assert( pCur == pCurTemp );
- if ( fVerbose ) printf( "Finished reading extension \"q\".\n" );
- }
- // read switching activity
- else if ( *pCur == 'u' )
- {
- unsigned char * pSwitching;
- pCur++;
- pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4; pCur += 4;
- pSwitching = ABC_ALLOC( unsigned char, Gia_ManObjNum(pNew) );
- memcpy( pSwitching, pCur, Gia_ManObjNum(pNew) ); pCur += Gia_ManObjNum(pNew);
- assert( pCur == pCurTemp );
- if ( fVerbose ) printf( "Finished reading extension \"s\".\n" );
- }
- // read timing manager
- else if ( *pCur == 't' )
- {
- pCur++;
- vStr = Vec_StrStart( Gia_AigerReadInt(pCur) ); pCur += 4;
- memcpy( Vec_StrArray(vStr), pCur, Vec_StrSize(vStr) ); pCur += Vec_StrSize(vStr);
- pNew->pManTime = Tim_ManLoad( vStr, 0 );
- Vec_StrFree( vStr );
- if ( fVerbose ) printf( "Finished reading extension \"t\".\n" );
- }
- // read object classes
- else if ( *pCur == 'v' )
- {
- pCur++;
- pNew->vObjClasses = Vec_IntStart( Gia_AigerReadInt(pCur)/4 ); pCur += 4;
- memcpy( Vec_IntArray(pNew->vObjClasses), pCur, 4*Vec_IntSize(pNew->vObjClasses) );
- pCur += 4*Vec_IntSize(pNew->vObjClasses);
- if ( fVerbose ) printf( "Finished reading extension \"v\".\n" );
- }
- // read edge information
- else if ( *pCur == 'w' )
- {
- Vec_Int_t * vPairs;
- int i, nPairs;
- pCur++;
- pCurTemp = pCur + Gia_AigerReadInt(pCur) + 4; pCur += 4;
- nPairs = Gia_AigerReadInt(pCur); pCur += 4;
- vPairs = Vec_IntAlloc( 2*nPairs );
- for ( i = 0; i < 2*nPairs; i++ )
- Vec_IntPush( vPairs, Gia_AigerReadInt(pCur) ), pCur += 4;
- assert( pCur == pCurTemp );
- if ( fSkipStrash )
- {
- Gia_ManEdgeFromArray( pNew, vPairs );
- if ( fVerbose ) printf( "Finished reading extension \"w\".\n" );
- }
- else
- printf( "Cannot read extension \"w\" because AIG is rehashed. Use \"&r -s <file.aig>\".\n" );
- Vec_IntFree( vPairs );
- }
- else break;
- }
- }
- // skipping the comments
- Vec_IntFree( vNodes );
- // update polarity of the additional outputs
- if ( nBad || nConstr || nJust || nFair )
- Gia_ManInvertConstraints( pNew );
- // clean the PO drivers
- if ( vPoTypes )
- {
- pNew = Gia_ManDupWithConstraints( pTemp = pNew, vPoTypes );
- Gia_ManStop( pTemp );
- Vec_IntFreeP( &vPoTypes );
- }
-
- if ( !fGiaSimple && !fSkipStrash && Gia_ManHasDangling(pNew) )
- {
- Tim_Man_t * pManTime;
- Vec_Int_t * vFlopMap, * vGateMap, * vObjMap;
- vFlopMap = pNew->vFlopClasses; pNew->vFlopClasses = NULL;
- vGateMap = pNew->vGateClasses; pNew->vGateClasses = NULL;
- vObjMap = pNew->vObjClasses; pNew->vObjClasses = NULL;
- pManTime = (Tim_Man_t *)pNew->pManTime; pNew->pManTime = NULL;
- pNew = Gia_ManCleanup( pTemp = pNew );
- if ( (vGateMap || vObjMap) && (Gia_ManObjNum(pNew) < Gia_ManObjNum(pTemp)) )
- printf( "Cleanup removed objects after reading. Old gate/object abstraction maps are invalid!\n" );
- Gia_ManStop( pTemp );
- pNew->vFlopClasses = vFlopMap;
- pNew->vGateClasses = vGateMap;
- pNew->vObjClasses = vObjMap;
- pNew->pManTime = pManTime;
- }
-
- if ( fHieOnly )
- {
- // Tim_ManPrint( (Tim_Man_t *)pNew->pManTime );
- if ( Abc_FrameReadLibBox() == NULL )
- printf( "Warning: Creating unit-delay box delay tables because box library is not available.\n" );
- Tim_ManCreate( (Tim_Man_t *)pNew->pManTime, Abc_FrameReadLibBox(), pNew->vInArrs, pNew->vOutReqs );
- }
- Vec_FltFreeP( &pNew->vInArrs );
- Vec_FltFreeP( &pNew->vOutReqs );
- /*
- // check the result
- if ( fCheck && !Gia_ManCheck( pNew ) )
- {
- printf( "Gia_AigerRead: The network check has failed.\n" );
- Gia_ManStop( pNew );
- return NULL;
- }
- */
-
- if ( vInits && Vec_IntSum(vInits) )
- {
- char * pInit = ABC_ALLOC( char, Vec_IntSize(vInits) + 1 );
- Gia_Obj_t * pObj;
- int i;
- assert( Vec_IntSize(vInits) == Gia_ManRegNum(pNew) );
- Gia_ManForEachRo( pNew, pObj, i )
- {
- if ( Vec_IntEntry(vInits, i) == 0 )
- pInit[i] = '0';
- else if ( Vec_IntEntry(vInits, i) == 1 )
- pInit[i] = '1';
- else
- {
- assert( Vec_IntEntry(vInits, i) == Abc_Var2Lit(Gia_ObjId(pNew, pObj), 0) );
- // unitialized value of the latch is the latch literal according to http://fmv.jku.at/hwmcc11/beyond1.pdf
- pInit[i] = 'X';
- }
- }
- pInit[i] = 0;
- pNew = Gia_ManDupZeroUndc( pTemp = pNew, pInit, fGiaSimple, 1 );
- pNew->nConstrs = pTemp->nConstrs; pTemp->nConstrs = 0;
- Gia_ManStop( pTemp );
- ABC_FREE( pInit );
- }
- Vec_IntFreeP( &vInits );
- if ( !fGiaSimple && !fSkipStrash && pNew->vMapping )
- {
- Abc_Print( 0, "Structural hashing enabled while reading AIGER invalidated the mapping. Consider using \"&r -s\".\n" );
- Vec_IntFreeP( &pNew->vMapping );
- }
- return pNew;
- }
- /**Function*************************************************************
- Synopsis [Reads the AIG in the binary AIGER format.]
- Description []
-
- SideEffects []
- SeeAlso []
- ***********************************************************************/
- Gia_Man_t * Gia_AigerRead( char * pFileName, int fGiaSimple, int fSkipStrash, int fCheck )
- {
- FILE * pFile;
- Gia_Man_t * pNew;
- char * pName, * pContents;
- int nFileSize;
- int RetValue;
- // read the file into the buffer
- Gia_FileFixName( pFileName );
- nFileSize = Gia_FileSize( pFileName );
- pFile = fopen( pFileName, "rb" );
- pContents = ABC_ALLOC( char, nFileSize );
- RetValue = fread( pContents, nFileSize, 1, pFile );
- fclose( pFile );
- pNew = Gia_AigerReadFromMemory( pContents, nFileSize, fGiaSimple, fSkipStrash, fCheck );
- ABC_FREE( pContents );
- if ( pNew )
- {
- ABC_FREE( pNew->pName );
- pName = Gia_FileNameGeneric( pFileName );
- pNew->pName = Abc_UtilStrsav( pName );
- ABC_FREE( pName );
-
- assert( pNew->pSpec == NULL );
- pNew->pSpec = Abc_UtilStrsav( pFileName );
- }
- return pNew;
- }
-
- /**Function*************************************************************
-
- Synopsis [Writes the AIG in into the memory buffer.]
-
- Description [The resulting buffer constains the AIG in AIGER format.
- The resulting buffer should be deallocated by the user.]
-
- SideEffects []
-
- SeeAlso []
-
- ***********************************************************************/
- Vec_Str_t * Gia_AigerWriteIntoMemoryStr( Gia_Man_t * p )
- {
- Vec_Str_t * vBuffer;
- Gia_Obj_t * pObj;
- int nNodes = 0, i, uLit, uLit0, uLit1;
- // set the node numbers to be used in the output file
- Gia_ManConst0(p)->Value = nNodes++;
- Gia_ManForEachCi( p, pObj, i )
- pObj->Value = nNodes++;
- Gia_ManForEachAnd( p, pObj, i )
- pObj->Value = nNodes++;
-
- // write the header "M I L O A" where M = I + L + A
- vBuffer = Vec_StrAlloc( 3*Gia_ManObjNum(p) );
- Vec_StrPrintStr( vBuffer, "aig " );
- Vec_StrPrintNum( vBuffer, Gia_ManCandNum(p) );
- Vec_StrPrintStr( vBuffer, " " );
- Vec_StrPrintNum( vBuffer, Gia_ManPiNum(p) );
- Vec_StrPrintStr( vBuffer, " " );
- Vec_StrPrintNum( vBuffer, Gia_ManRegNum(p) );
- Vec_StrPrintStr( vBuffer, " " );
- Vec_StrPrintNum( vBuffer, Gia_ManPoNum(p) );
- Vec_StrPrintStr( vBuffer, " " );
- Vec_StrPrintNum( vBuffer, Gia_ManAndNum(p) );
- Vec_StrPrintStr( vBuffer, "\n" );
-
- // write latch drivers
- Gia_ManForEachRi( p, pObj, i )
- {
- uLit = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
- Vec_StrPrintNum( vBuffer, uLit );
- Vec_StrPrintStr( vBuffer, "\n" );
- }
-
- // write PO drivers
- Gia_ManForEachPo( p, pObj, i )
- {
- uLit = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
- Vec_StrPrintNum( vBuffer, uLit );
- Vec_StrPrintStr( vBuffer, "\n" );
- }
- // write the nodes into the buffer
- Gia_ManForEachAnd( p, pObj, i )
- {
- uLit = Abc_Var2Lit( Gia_ObjValue(pObj), 0 );
- uLit0 = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
- uLit1 = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin1(pObj)), Gia_ObjFaninC1(pObj) );
- assert( uLit0 != uLit1 );
- if ( uLit0 > uLit1 )
- {
- int Temp = uLit0;
- uLit0 = uLit1;
- uLit1 = Temp;
- }
- Gia_AigerWriteUnsigned( vBuffer, uLit - uLit1 );
- Gia_AigerWriteUnsigned( vBuffer, uLit1 - uLit0 );
- }
- Vec_StrPrintStr( vBuffer, "c" );
- return vBuffer;
- }
-
- /**Function*************************************************************
-
- Synopsis [Writes the AIG in into the memory buffer.]
-
- Description [The resulting buffer constains the AIG in AIGER format.
- The CI/CO/AND nodes are assumed to be ordered according to some rule.
- The resulting buffer should be deallocated by the user.]
-
- SideEffects [Note that in vCos, PIs are order first, followed by latches!]
-
- SeeAlso []
-
- ***********************************************************************/
- Vec_Str_t * Gia_AigerWriteIntoMemoryStrPart( Gia_Man_t * p, Vec_Int_t * vCis, Vec_Int_t * vAnds, Vec_Int_t * vCos, int nRegs )
- {
- Vec_Str_t * vBuffer;
- Gia_Obj_t * pObj;
- int nNodes = 0, i, uLit, uLit0, uLit1;
- // set the node numbers to be used in the output file
- Gia_ManConst0(p)->Value = nNodes++;
- Gia_ManForEachObjVec( vCis, p, pObj, i )
- {
- assert( Gia_ObjIsCi(pObj) );
- pObj->Value = nNodes++;
- }
- Gia_ManForEachObjVec( vAnds, p, pObj, i )
- {
- assert( Gia_ObjIsAnd(pObj) );
- pObj->Value = nNodes++;
- }
-
- // write the header "M I L O A" where M = I + L + A
- vBuffer = Vec_StrAlloc( 3*Gia_ManObjNum(p) );
- Vec_StrPrintStr( vBuffer, "aig " );
- Vec_StrPrintNum( vBuffer, Vec_IntSize(vCis) + Vec_IntSize(vAnds) );
- Vec_StrPrintStr( vBuffer, " " );
- Vec_StrPrintNum( vBuffer, Vec_IntSize(vCis) - nRegs );
- Vec_StrPrintStr( vBuffer, " " );
- Vec_StrPrintNum( vBuffer, nRegs );
- Vec_StrPrintStr( vBuffer, " " );
- Vec_StrPrintNum( vBuffer, Vec_IntSize(vCos) - nRegs );
- Vec_StrPrintStr( vBuffer, " " );
- Vec_StrPrintNum( vBuffer, Vec_IntSize(vAnds) );
- Vec_StrPrintStr( vBuffer, "\n" );
-
- // write latch drivers
- Gia_ManForEachObjVec( vCos, p, pObj, i )
- {
- assert( Gia_ObjIsCo(pObj) );
- if ( i < Vec_IntSize(vCos) - nRegs )
- continue;
- uLit = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
- Vec_StrPrintNum( vBuffer, uLit );
- Vec_StrPrintStr( vBuffer, "\n" );
- }
- // write output drivers
- Gia_ManForEachObjVec( vCos, p, pObj, i )
- {
- assert( Gia_ObjIsCo(pObj) );
- if ( i >= Vec_IntSize(vCos) - nRegs )
- continue;
- uLit = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
- Vec_StrPrintNum( vBuffer, uLit );
- Vec_StrPrintStr( vBuffer, "\n" );
- }
-
- // write the nodes into the buffer
- Gia_ManForEachObjVec( vAnds, p, pObj, i )
- {
- uLit = Abc_Var2Lit( Gia_ObjValue(pObj), 0 );
- uLit0 = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
- uLit1 = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin1(pObj)), Gia_ObjFaninC1(pObj) );
- assert( uLit0 != uLit1 );
- if ( uLit0 > uLit1 )
- {
- int Temp = uLit0;
- uLit0 = uLit1;
- uLit1 = Temp;
- }
- Gia_AigerWriteUnsigned( vBuffer, uLit - uLit1 );
- Gia_AigerWriteUnsigned( vBuffer, uLit1 - uLit0 );
- }
- Vec_StrPrintStr( vBuffer, "c" );
- return vBuffer;
- }
-
- /**Function*************************************************************
-
- Synopsis [Writes the AIG in the binary AIGER format.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
- ***********************************************************************/
- void Gia_AigerWrite( Gia_Man_t * pInit, char * pFileName, int fWriteSymbols, int fCompact )
- {
- int fVerbose = XAIG_VERBOSE;
- FILE * pFile;
- Gia_Man_t * p;
- Gia_Obj_t * pObj;
- Vec_Str_t * vStrExt;
- int i, nBufferSize, Pos;
- unsigned char * pBuffer;
- unsigned uLit0, uLit1, uLit;
- assert( pInit->nXors == 0 && pInit->nMuxes == 0 );
- if ( Gia_ManCoNum(pInit) == 0 )
- {
- printf( "AIG cannot be written because it has no POs.\n" );
- return;
- }
- // start the output stream
- pFile = fopen( pFileName, "wb" );
- if ( pFile == NULL )
- {
- fprintf( stdout, "Gia_AigerWrite(): Cannot open the output file \"%s\".\n", pFileName );
- return;
- }
- // create normalized AIG
- if ( !Gia_ManIsNormalized(pInit) )
- {
- // printf( "Gia_AigerWrite(): Normalizing AIG for writing.\n" );
- p = Gia_ManDupNormalize( pInit, 0 );
- Gia_ManTransferMapping( p, pInit );
- Gia_ManTransferPacking( p, pInit );
- Gia_ManTransferTiming( p, pInit );
- p->vNamesIn = pInit->vNamesIn; pInit->vNamesIn = NULL;
- p->vNamesOut = pInit->vNamesOut; pInit->vNamesOut = NULL;
- p->nConstrs = pInit->nConstrs; pInit->nConstrs = 0;
- }
- else
- p = pInit;
- // write the header "M I L O A" where M = I + L + A
- fprintf( pFile, "aig%s %u %u %u %u %u",
- fCompact? "2" : "",
- Gia_ManCiNum(p) + Gia_ManAndNum(p),
- Gia_ManPiNum(p),
- Gia_ManRegNum(p),
- Gia_ManConstrNum(p) ? 0 : Gia_ManPoNum(p),
- Gia_ManAndNum(p) );
- // write the extended header "B C J F"
- if ( Gia_ManConstrNum(p) )
- fprintf( pFile, " %u %u", Gia_ManPoNum(p) - Gia_ManConstrNum(p), Gia_ManConstrNum(p) );
- fprintf( pFile, "\n" );
- Gia_ManInvertConstraints( p );
- if ( !fCompact )
- {
- // write latch drivers
- Gia_ManForEachRi( p, pObj, i )
- fprintf( pFile, "%u\n", Gia_ObjFaninLit0p(p, pObj) );
- // write PO drivers
- Gia_ManForEachPo( p, pObj, i )
- fprintf( pFile, "%u\n", Gia_ObjFaninLit0p(p, pObj) );
- }
- else
- {
- Vec_Int_t * vLits = Gia_AigerCollectLiterals( p );
- Vec_Str_t * vBinary = Gia_AigerWriteLiterals( vLits );
- fwrite( Vec_StrArray(vBinary), 1, Vec_StrSize(vBinary), pFile );
- Vec_StrFree( vBinary );
- Vec_IntFree( vLits );
- }
- Gia_ManInvertConstraints( p );
- // write the nodes into the buffer
- Pos = 0;
- nBufferSize = 8 * Gia_ManAndNum(p) + 100; // skeptically assuming 3 chars per one AIG edge
- pBuffer = ABC_ALLOC( unsigned char, nBufferSize );
- Gia_ManForEachAnd( p, pObj, i )
- {
- uLit = Abc_Var2Lit( i, 0 );
- uLit0 = Gia_ObjFaninLit0( pObj, i );
- uLit1 = Gia_ObjFaninLit1( pObj, i );
- assert( p->fGiaSimple || Gia_ManBufNum(p) || uLit0 < uLit1 );
- Pos = Gia_AigerWriteUnsignedBuffer( pBuffer, Pos, uLit - uLit1 );
- Pos = Gia_AigerWriteUnsignedBuffer( pBuffer, Pos, uLit1 - uLit0 );
- if ( Pos > nBufferSize - 10 )
- {
- printf( "Gia_AigerWrite(): AIGER generation has failed because the allocated buffer is too small.\n" );
- fclose( pFile );
- if ( p != pInit )
- Gia_ManStop( p );
- return;
- }
- }
- assert( Pos < nBufferSize );
- // write the buffer
- fwrite( pBuffer, 1, Pos, pFile );
- ABC_FREE( pBuffer );
- // write the symbol table
- if ( p->vNamesIn && p->vNamesOut )
- {
- assert( Vec_PtrSize(p->vNamesIn) == Gia_ManCiNum(p) );
- assert( Vec_PtrSize(p->vNamesOut) == Gia_ManCoNum(p) );
- // write PIs
- Gia_ManForEachPi( p, pObj, i )
- fprintf( pFile, "i%d %s\n", i, (char *)Vec_PtrEntry(p->vNamesIn, i) );
- // write latches
- Gia_ManForEachRo( p, pObj, i )
- fprintf( pFile, "l%d %s\n", i, (char *)Vec_PtrEntry(p->vNamesIn, Gia_ManPiNum(p) + i) );
- // write POs
- Gia_ManForEachPo( p, pObj, i )
- fprintf( pFile, "o%d %s\n", i, (char *)Vec_PtrEntry(p->vNamesOut, i) );
- }
- // write the comment
- // fprintf( pFile, "c\n" );
- fprintf( pFile, "c" );
- // write additional AIG
- if ( p->pAigExtra )
- {
- fprintf( pFile, "a" );
- vStrExt = Gia_AigerWriteIntoMemoryStr( p->pAigExtra );
- Gia_FileWriteBufferSize( pFile, Vec_StrSize(vStrExt) );
- fwrite( Vec_StrArray(vStrExt), 1, Vec_StrSize(vStrExt), pFile );
- Vec_StrFree( vStrExt );
- if ( fVerbose ) printf( "Finished writing extension \"a\".\n" );
- }
- // write constraints
- if ( p->nConstrs )
- {
- fprintf( pFile, "c" );
- Gia_FileWriteBufferSize( pFile, 4 );
- Gia_FileWriteBufferSize( pFile, p->nConstrs );
- }
- // write timing information
- if ( p->nAnd2Delay )
- {
- fprintf( pFile, "d" );
- Gia_FileWriteBufferSize( pFile, 4 );
- Gia_FileWriteBufferSize( pFile, p->nAnd2Delay );
- }
- if ( p->pManTime )
- {
- float * pTimes;
- pTimes = Tim_ManGetArrTimes( (Tim_Man_t *)p->pManTime );
- if ( pTimes )
- {
- fprintf( pFile, "i" );
- Gia_FileWriteBufferSize( pFile, 4*Tim_ManPiNum((Tim_Man_t *)p->pManTime) );
- fwrite( pTimes, 1, 4*Tim_ManPiNum((Tim_Man_t *)p->pManTime), pFile );
- ABC_FREE( pTimes );
- if ( fVerbose ) printf( "Finished writing extension \"i\".\n" );
- }
- pTimes = Tim_ManGetReqTimes( (Tim_Man_t *)p->pManTime );
- if ( pTimes )
- {
- fprintf( pFile, "o" );
- Gia_FileWriteBufferSize( pFile, 4*Tim_ManPoNum((Tim_Man_t *)p->pManTime) );
- fwrite( pTimes, 1, 4*Tim_ManPoNum((Tim_Man_t *)p->pManTime), pFile );
- ABC_FREE( pTimes );
- if ( fVerbose ) printf( "Finished writing extension \"o\".\n" );
- }
- }
- // write equivalences
- if ( p->pReprs && p->pNexts )
- {
- extern Vec_Str_t * Gia_WriteEquivClasses( Gia_Man_t * p );
- fprintf( pFile, "e" );
- vStrExt = Gia_WriteEquivClasses( p );
- Gia_FileWriteBufferSize( pFile, Vec_StrSize(vStrExt) );
- fwrite( Vec_StrArray(vStrExt), 1, Vec_StrSize(vStrExt), pFile );
- Vec_StrFree( vStrExt );
- }
- // write flop classes
- if ( p->vFlopClasses )
- {
- fprintf( pFile, "f" );
- Gia_FileWriteBufferSize( pFile, 4*Gia_ManRegNum(p) );
- assert( Vec_IntSize(p->vFlopClasses) == Gia_ManRegNum(p) );
- fwrite( Vec_IntArray(p->vFlopClasses), 1, 4*Gia_ManRegNum(p), pFile );
- }
- // write gate classes
- if ( p->vGateClasses )
- {
- fprintf( pFile, "g" );
- Gia_FileWriteBufferSize( pFile, 4*Gia_ManObjNum(p) );
- assert( Vec_IntSize(p->vGateClasses) == Gia_ManObjNum(p) );
- fwrite( Vec_IntArray(p->vGateClasses), 1, 4*Gia_ManObjNum(p), pFile );
- }
- // write hierarchy info
- if ( p->pManTime )
- {
- fprintf( pFile, "h" );
- vStrExt = Tim_ManSave( (Tim_Man_t *)p->pManTime, 1 );
- Gia_FileWriteBufferSize( pFile, Vec_StrSize(vStrExt) );
- fwrite( Vec_StrArray(vStrExt), 1, Vec_StrSize(vStrExt), pFile );
- Vec_StrFree( vStrExt );
- if ( fVerbose ) printf( "Finished writing extension \"h\".\n" );
- }
- // write packing
- if ( p->vPacking )
- {
- extern Vec_Str_t * Gia_WritePacking( Vec_Int_t * vPacking );
- fprintf( pFile, "k" );
- vStrExt = Gia_WritePacking( p->vPacking );
- Gia_FileWriteBufferSize( pFile, Vec_StrSize(vStrExt) );
- fwrite( Vec_StrArray(vStrExt), 1, Vec_StrSize(vStrExt), pFile );
- Vec_StrFree( vStrExt );
- if ( fVerbose ) printf( "Finished writing extension \"k\".\n" );
- }
- // write edges
- if ( p->vEdge1 )
- {
- Vec_Int_t * vPairs = Gia_ManEdgeToArray( p );
- int i;
- fprintf( pFile, "w" );
- Gia_FileWriteBufferSize( pFile, 4*(Vec_IntSize(vPairs)+1) );
- Gia_FileWriteBufferSize( pFile, Vec_IntSize(vPairs)/2 );
- for ( i = 0; i < Vec_IntSize(vPairs); i++ )
- Gia_FileWriteBufferSize( pFile, Vec_IntEntry(vPairs, i) );
- Vec_IntFree( vPairs );
- }
- // write mapping
- if ( Gia_ManHasMapping(p) )
- {
- extern Vec_Str_t * Gia_AigerWriteMapping( Gia_Man_t * p );
- extern Vec_Str_t * Gia_AigerWriteMappingSimple( Gia_Man_t * p );
- extern Vec_Str_t * Gia_AigerWriteMappingDoc( Gia_Man_t * p );
- fprintf( pFile, "m" );
- vStrExt = Gia_AigerWriteMappingDoc( p );
- Gia_FileWriteBufferSize( pFile, Vec_StrSize(vStrExt) );
- fwrite( Vec_StrArray(vStrExt), 1, Vec_StrSize(vStrExt), pFile );
- Vec_StrFree( vStrExt );
- if ( fVerbose ) printf( "Finished writing extension \"m\".\n" );
- }
- // write placement
- if ( p->pPlacement )
- {
- fprintf( pFile, "p" );
- Gia_FileWriteBufferSize( pFile, 4*Gia_ManObjNum(p) );
- fwrite( p->pPlacement, 1, 4*Gia_ManObjNum(p), pFile );
- }
- // write register classes
- if ( p->vRegClasses )
- {
- int i;
- …
Large files files are truncated, but you can click here to view the full file