/**Function*************************************************************
Synopsis [Transform the netlist into a logic network.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Abc_Ntk_t * Abc_NtkToLogic( Abc_Ntk_t * pNtk )
{
Abc_Ntk_t * pNtkNew;
Abc_Obj_t * pObj, * pFanin;
int i, k;
// consider the case of the AIG
if ( Abc_NtkIsStrash(pNtk) )
return Abc_NtkAigToLogicSop( pNtk );
assert( Abc_NtkIsNetlist(pNtk) );
// consider simple case when there is hierarchy
// assert( pNtk->pDesign == NULL );
assert( Abc_NtkWhiteboxNum(pNtk) == 0 );
assert( Abc_NtkBlackboxNum(pNtk) == 0 );
// start the network
pNtkNew = Abc_NtkStartFrom( pNtk, ABC_NTK_LOGIC, pNtk->ntkFunc );
// duplicate the nodes
Abc_NtkForEachNode( pNtk, pObj, i )
Abc_NtkDupObj(pNtkNew, pObj, 0);
// reconnect the internal nodes in the new network
Abc_NtkForEachNode( pNtk, pObj, i )
Abc_ObjForEachFanin( pObj, pFanin, k )
Abc_ObjAddFanin( pObj->pCopy, Abc_ObjFanin0(pFanin)->pCopy );
// collect the CO nodes
Abc_NtkFinalize( pNtk, pNtkNew );
// fix the problem with CO pointing directly to CIs
Abc_NtkLogicMakeSimpleCos( pNtkNew, 0 );
// duplicate EXDC
if ( pNtk->pExdc )
pNtkNew->pExdc = Abc_NtkToLogic( pNtk->pExdc );
if ( !Abc_NtkCheck( pNtkNew ) )
fprintf( stdout, "Abc_NtkToLogic(): Network check has failed.\n" );
return pNtkNew;
}
/**Function*************************************************************
Synopsis [Starts a new network using existing network as a model.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Abc_Ntk_t * Abc_NtkStartFromNoLatches( Abc_Ntk_t * pNtk, Abc_NtkType_t Type, Abc_NtkFunc_t Func )
{
Abc_Ntk_t * pNtkNew;
Abc_Obj_t * pObj;
int i;
if ( pNtk == NULL )
return NULL;
assert( Type != ABC_NTK_NETLIST );
// start the network
pNtkNew = Abc_NtkAlloc( Type, Func, 1 );
// duplicate the name and the spec
pNtkNew->pName = Extra_UtilStrsav(pNtk->pName);
pNtkNew->pSpec = Extra_UtilStrsav(pNtk->pSpec);
// clean the node copy fields
Abc_NtkCleanCopy( pNtk );
// map the constant nodes
if ( Abc_NtkIsStrash(pNtk) && Abc_NtkIsStrash(pNtkNew) )
Abc_AigConst1(pNtk)->pCopy = Abc_AigConst1(pNtkNew);
// clone CIs/CIs/boxes
Abc_NtkForEachPi( pNtk, pObj, i )
Abc_NtkDupObj( pNtkNew, pObj, 1 );
Abc_NtkForEachPo( pNtk, pObj, i )
Abc_NtkDupObj( pNtkNew, pObj, 1 );
Abc_NtkForEachAssert( pNtk, pObj, i )
Abc_NtkDupObj( pNtkNew, pObj, 1 );
Abc_NtkForEachBox( pNtk, pObj, i )
{
if ( Abc_ObjIsLatch(pObj) )
continue;
Abc_NtkDupBox(pNtkNew, pObj, 1);
}
// transfer the names
// Abc_NtkTrasferNamesNoLatches( pNtk, pNtkNew );
Abc_ManTimeDup( pNtk, pNtkNew );
// check that the CI/CO/latches are copied correctly
assert( Abc_NtkPiNum(pNtk) == Abc_NtkPiNum(pNtkNew) );
assert( Abc_NtkPoNum(pNtk) == Abc_NtkPoNum(pNtkNew) );
return pNtkNew;
}
Abc_Ntk_t * My_Command_Associative(Abc_Ntk_t * pNtk)
{// check abc.h and abcNtk.c(Abc_ntkDup, duplication) freeXXX
//a new network to return
printf("inside the My_Command_Associative\n");
Abc_Ntk_t * new_pNtk;
Abc_Obj_t * pObj;
int i, j,k,m;
int changed = 0;
//check partial nodes satisfying a certain associative law
Abc_NtkForEachObj( pNtk, pObj, i)
{
//printf("Node ID: %d \n", Abc_ObjId(pObj));
//printf("FanInNum: %d \n",Abc_ObjFaninNum(pObj));
if(changed <1 && Abc_ObjFaninNum(pObj) == 2 && !Abc_ObjFaninC0(pObj) && !Abc_ObjFaninC1(pObj) )
{
Abc_Obj_t * pFanin_0 = Abc_ObjFanin0(pObj);
Abc_Obj_t * pFanin_1 = Abc_ObjFanin1(pObj);
// (x*y)*z => x*(y*z)
if(changed <1 && Abc_ObjFaninNum(pFanin_0) == 2 && !Abc_ObjFaninC0(pFanin_0) && !Abc_ObjFaninC1(pFanin_0) ) // (x*y)*z => x*(y*z)
{
printf("1st Condition, Node ID: %d\n",Abc_ObjId(pObj) );
printf("Abc_ObjFaninNum(pFanin_0): Node ID: %d\n",Abc_ObjId(pFanin_0) );
Abc_Obj_t * tempObj;
Abc_Obj_t * pFanin_0_0 = Abc_ObjFanin0(pFanin_0);
Abc_Obj_t * pFanin_0_1 = Abc_ObjFanin1(pFanin_0);
Abc_Obj_t * NewParentNode = Abc_NtkDupObj(pNtk, pObj, 1);
Abc_Obj_t * NewChildNode = Abc_NtkDupObj(pNtk, pFanin_0, 1);
int FanoutNum = Abc_ObjFanoutNum(pObj);
for (j=0; j<FanoutNum; j++)
{
tempObj = Abc_ObjFanout(pObj, j);
Abc_ObjDeleteFanin( tempObj , pObj );
Abc_ObjAddFanin( tempObj, NewParentNode);
}
printf("ParentNode Created and connected\n" );
Abc_ObjAddFanin(NewParentNode,pFanin_0_0 );
Abc_ObjAddFanin( NewParentNode, NewChildNode );
Abc_ObjAddFanin( NewChildNode, pFanin_0_1);
Abc_ObjAddFanin(NewChildNode,pFanin_1 );
printf("ChildNode Created and connected\n" );
printf("Abc_ObjFanoutNum(pFanin_0): %d\n",Abc_ObjFanoutNum(pFanin_0) );
if(Abc_ObjFanoutNum(pFanin_0)>1)
{
printf("pFanin_0 's FanOut > 1\n" );
}
else
{
Abc_ObjForEachFanin(pFanin_0,tempObj, k )
{
Abc_ObjDeleteFanin(pFanin_0,tempObj);
}
Abc_NtkDeleteObj(pFanin_0);
}
Abc_ObjForEachFanin(pObj,tempObj, k )
{
Abc_ObjDeleteFanin(pObj,tempObj);
}
