oagFpgaModGraph.cpp

Go to the documentation of this file.

#include "oagFpga.h"
#include "oagFpgaModGraph.h"
#include <set>

#include "oagFpgaDebug.h"

namespace oagFpga {

// *****************************************************************************
// failIfInDifferentModules()
//
//
// *****************************************************************************
inline void
ModGraph::failIfInDifferentModules(oa::oaModule *x, oa::oaModule *y) {
    if (x != y) {
        cerr << "ERROR: Expected ModRefs that refer to nodes in the same module" << endl;    
        QUIT_ON_ERROR;
    }
}     


// *****************************************************************************
// convertRefListToModRefList()
//
//
// *****************************************************************************
void
ModGraph::convertRefListToModRefList(const list<BBRef> & source,
                                     oa::oaModule *module,
                                     list<ModRef> & result) {
    for(list<BBRef>::const_iterator it = source.begin(); it != source.end(); ++it) {
        result.push_back(ModRef(*it, module));
    }
}

// *****************************************************************************
// convertModRefListToRefList()
//
//
// *****************************************************************************
oa::oaModule*
ModGraph::convertModRefListToRefList(const list<ModRef> & source,
                                     list<BBRef> & result) {
    if (source.empty()) return NULL;
    oa::oaModule *module = source.front().module;
    for(list<ModRef>::const_iterator it = source.begin(); it != source.end(); ++it) {
      assert(it->module == module);
      result.push_back(it->ref);
    }
    return module;
}

// *****************************************************************************
// convertRefVectorToModRefVector()
//
//
// *****************************************************************************
void
ModGraph::convertRefVectorToModRefVector(const vector<BBRef> & source,
                                         oa::oaModule *module,
                                         vector<ModRef> & result) {
  result.reserve(source.size());
  for(vector<BBRef>::const_iterator it = source.begin(); it != source.end(); ++it) {
    result.push_back(ModRef(*it, module));
  }
}

/*
// *****************************************************************************
// newAnd()
//
//
// *****************************************************************************
ModRef
ModGraph::newAnd(ModRef x, ModRef y) {
    failIfInDifferentModules(x,y);
    
    return ModRef(getGraph(x)->newAnd(x.ref, y.ref), x.module);
}


// *****************************************************************************
// andOf()
//
// *****************************************************************************
ModRef
ModGraph::andOf(ModRef x, ModRef y) {
    failIfInDifferentModules(x,y);
    
    return ModRef(getGraph(x)->andOf(x.ref, y.ref), x.module);
}
    
*/

// *****************************************************************************
// setTerminalDriver()
//
// *****************************************************************************
void
ModGraph::setTerminalDriver(ModRef terminal, ModRef driver) {
    failIfInDifferentModules(terminal, driver);

    getGraph(terminal)->setTerminalDriver(terminal.ref, driver.ref);
}

/*

// *****************************************************************************
// setAndLeft()
//
//
// *****************************************************************************
void
ModGraph::setAndLeft(ModRef x, ModRef left) {
    failIfInDifferentModules(x,left);

    getGraph(x)->setAndLeft(x.ref, left.ref);
}


// *****************************************************************************
// setAndRight()
//
//
// *****************************************************************************
void
ModGraph::setAndRight(ModRef x, ModRef right) {
    failIfInDifferentModules(x,right);

    getGraph(x)->setAndRight(x.ref, right.ref);
}


// *****************************************************************************
// setNextState()
//
//
// *****************************************************************************
void
ModGraph::setNextState(ModRef sequential, ModRef nextState) {
    failIfInDifferentModules(sequential, nextState);

    getGraph(sequential)->setNextState(sequential.ref, nextState.ref);
}


// *****************************************************************************
// resubsitute()
//
//
// *****************************************************************************
void
ModGraph::resubstitute(ModRef original, ModRef replacement) {
    failIfInDifferentModules(original, replacement);

    getGraph(original)->resubstitute(original.ref, replacement.ref);
}


// *****************************************************************************
// resubsitute()
//
//
// *****************************************************************************
void
ModGraph::resubstitute(ModRef original, ModRef replacement, ModRef target) {
    failIfInDifferentModules(original, replacement);
    failIfInDifferentModules(original, target);
    
    getGraph(original)->resubstitute(original.ref, replacement.ref, target.ref);
}


// *****************************************************************************
// detach()
//
//
// *****************************************************************************
void
ModGraph::detach(ModRef x) {

    getGraph(x)->detach(x.ref);
}
*/

// *****************************************************************************
//  hasCombinationalCycle()
//
// *****************************************************************************
bool
ModGraph::hasCombinationalCycle(oa::oaModule *module) {
    return getGraph(module)->hasCombinationalCycle();
}

/*
// *****************************************************************************
// enumerateKfeasibleCuts()
//
// *****************************************************************************
ModGraph::CutSet
ModGraph::enumerateKfeasibleCuts(ModRef x, unsigned int maxCutSize, 
                                 int maxCutCount, int maxCutDepth,
                                 bool includeConstantNode) {
  oagAi::Graph::CutSet *source = getGraph(x)->enumerateKfeasibleCuts(x.ref, 
                                                                     maxCutSize, maxCutCount, maxCutDepth,
                                                                     includeConstantNode);

    // convert cuts in Refs to cuts in ModRefs
    CutSet result;
    for(oagAi::Graph::CutSet::iterator setIter = source->begin(); setIter != source->end(); ++setIter) {
        Cut    resultCut;
        for(oagAi::Graph::Cut::iterator cutIter = setIter->begin(); cutIter != setIter->end(); ++cutIter) {
            resultCut.insert(ModRef(*cutIter, x.module));
        }
        result.push_back(resultCut);
    }
    return result;
}


// *****************************************************************************
// clearKfeasibleCuts()
//
//
// *****************************************************************************
void
ModGraph::clearKfeasibleCuts(oa::oaModule *module) {
    getGraph(module)->clearKfeasibleCuts();
}

*/

// *****************************************************************************
// getFanin()
//
//
// *****************************************************************************
list<ModRef>
ModGraph::getFanin(ModRef x) {
    list<ModRef> result;
    convertRefListToModRefList(getGraph(x)->getFanin(x.ref), x.module, result);
    return result;
}
 
// *****************************************************************************
// getFanout()
//
//
// *****************************************************************************
list<ModRef>
ModGraph::getFanout(ModRef x) {
    list<ModRef> result;
    convertRefListToModRefList(getGraph(x)->getFanout(x.ref), x.module, result);
    return result;
}
    
    
// *****************************************************************************
// getFanout()
//
//
// *****************************************************************************
void
ModGraph::getFanout(ModRef x, list<ModRef> &result) {
    convertRefListToModRefList(getGraph(x)->getFanout(x.ref), x.module, result);
}

// *****************************************************************************
// getTransitiveFanin()
//
//
// *****************************************************************************
void
ModGraph::getTransitiveFanin(ModRef x, list<ModRef> &transitiveFanin, 
                             bool includeRoots, bool crossSequential) {
    list<BBRef> flatResult;
    getGraph(x)->getTransitiveFanin(x.ref, flatResult, 
                                    includeRoots, crossSequential);
    convertRefListToModRefList(flatResult, x.module, transitiveFanin);
}

// *****************************************************************************
// getTransitiveFanout()
//
//
// *****************************************************************************
void
ModGraph::getTransitiveFanout(ModRef x, list<ModRef> &transitiveFanout,
                              bool includeRoots, bool crossSequential) {
    list<BBRef> flatResult;
    getGraph(x)->getTransitiveFanout(x.ref, flatResult, 
                                     includeRoots, crossSequential);
    convertRefListToModRefList(flatResult, x.module, transitiveFanout);
}


// *****************************************************************************
// getTransitiveFanin()
//
//
// *****************************************************************************
void
ModGraph::getTransitiveFanin(ModRef x, vector<ModRef> &transitiveFanin,
                             bool includeRoots, bool crossSequential) {
    vector<BBRef> flatResult;
    getGraph(x)->getTransitiveFanin(x.ref, flatResult, 
                                    includeRoots, crossSequential);
    convertRefVectorToModRefVector(flatResult, x.module, transitiveFanin);
}


// *****************************************************************************
// getTransitiveFanout()
//
//
// *****************************************************************************
void
ModGraph::getTransitiveFanout(ModRef x, vector<ModRef> &transitiveFanout,
                              bool includeRoots, bool crossSequential) {
    vector<BBRef> flatResult;
    getGraph(x)->getTransitiveFanout(x.ref, flatResult, 
                                     includeRoots, crossSequential);
    convertRefVectorToModRefVector(flatResult, x.module, transitiveFanout);
}


// *****************************************************************************
// getTransitiveFanin()
//
//
// *****************************************************************************
void
ModGraph::getTransitiveFanin(list<ModRef> x, list<ModRef> &transitiveFanin, 
                             bool includeRoots, bool crossSequential) {
    if (x.empty()) return;
    list<BBRef> flatInput;
    oa::oaModule *module = convertModRefListToRefList(x, flatInput);
    list<BBRef> flatResult;
    getGraph(module)->getTransitiveFanin(flatInput, flatResult, 
                                         includeRoots, crossSequential);
    convertRefListToModRefList(flatResult, module, transitiveFanin);
}


// *****************************************************************************
// getTransitiveFanout()
//
//
// *****************************************************************************
void
ModGraph::getTransitiveFanout(list<ModRef> x, list<ModRef> &transitiveFanout,
                              bool includeRoots, bool crossSequential) {
    if (x.empty()) return;
    list<BBRef> flatInput;
    oa::oaModule *module = convertModRefListToRefList(x, flatInput);
    list<BBRef> flatResult;
    getGraph(module)->getTransitiveFanout(flatInput, flatResult, 
                                          includeRoots, crossSequential);
    convertRefListToModRefList(flatResult, module, transitiveFanout);
}


// *****************************************************************************
// getTransitiveFanin()
//
//
// *****************************************************************************
void
ModGraph::getTransitiveFanin(list<ModRef> x, vector<ModRef> &transitiveFanin,
                             bool includeRoots, bool crossSequential) {
    if (x.empty()) return;
    list<BBRef> flatInput;
    oa::oaModule *module = convertModRefListToRefList(x, flatInput);
    vector<BBRef> flatResult;
    getGraph(module)->getTransitiveFanin(flatInput, flatResult, 
                                         includeRoots, crossSequential);
    convertRefVectorToModRefVector(flatResult, module, transitiveFanin);
}


// *****************************************************************************
// getTransitiveFanout()
//
//
// *****************************************************************************
void
ModGraph::getTransitiveFanout(list<ModRef> x, vector<ModRef> &transitiveFanout,
                              bool includeRoots, bool crossSequential) {
    if (x.empty()) return;
    list<BBRef> flatInput;
    oa::oaModule *module = convertModRefListToRefList(x, flatInput);
    vector<BBRef> flatResult;
    getGraph(module)->getTransitiveFanout(flatInput, flatResult, 
                                          includeRoots, crossSequential);
    convertRefVectorToModRefVector(flatResult, module, transitiveFanout);
}


/*

// *****************************************************************************
// getFaninRoots()
//
//
// *****************************************************************************
void
ModGraph::getFaninRoots(ModRef x, list<ModRef> &faninRoots) {
    list<oagAi::Ref> flatResult;
    getGraph(x)->getFaninRoots(x.ref, flatResult);
    
    convertRefListToModRefList(flatResult, x.module, faninRoots);
}


// *****************************************************************************
// getFanoutRoots()
//
//
// *****************************************************************************
void
ModGraph::getFanoutRoots(ModRef x, list<ModRef> &fanoutRoots) {
    list<oagAi::Ref> flatResult;
    getGraph(x)->getFanoutRoots(x.ref, flatResult);
    
    convertRefListToModRefList(flatResult, x.module, fanoutRoots);
}


// *****************************************************************************
// testEquivalence()
//
//
// *****************************************************************************
bool
ModGraph::testEquivalence(ModRef x, ModRef y) {
    failIfInDifferentModules(x,y);

    return getGraph(x)->testEquivalence(x.ref, y.ref);
}


// *****************************************************************************
// setEquivalent()
//
//
// *****************************************************************************
void
ModGraph::setEquivalent(ModRef x, ModRef y) {
    failIfInDifferentModules(x,y);

    getGraph(x)->setEquivalent(x.ref, y.ref);
}


// *****************************************************************************
// getEquivalents()
//
//
// *****************************************************************************
void
ModGraph::getEquivalents(ModRef x, list<ModRef> & result) {
    list<oagAi::Ref> flatResult;
    getGraph(x)->getEquivalents(x.ref, flatResult);
    
    convertRefListToModRefList(flatResult, x.module, result);
}


// *****************************************************************************
// getFanoutOfEquivalentNodes()
//
//
// *****************************************************************************
void
ModGraph::getFanoutOfEquivalentNodes(ModRef x, list<ModRef> &result) {
    list<oagAi::Ref> flatResult;
    getGraph(x)->getFanoutOfEquivalentNodes(x.ref, flatResult);
    
    convertRefListToModRefList(flatResult, x.module, result);
}

*/

// *****************************************************************************
// prepareNetToBBConnection()
//
//
// *****************************************************************************
ModRef   
ModGraph::prepareNetToBBConnection(oa::oaModBitNet *net) {
    Manager *manager = Manager::get(net->getDesign());
    return ModRef(manager->prepareNetToBBConnection(net), net->getModule());
}


// *****************************************************************************
// getNetToBBConnection()
//
//
// *****************************************************************************
oa::oaModBitNet *   
ModGraph::getNetToBBConnection(ModRef x) {
    Manager *manager = Manager::get(x.module->getDesign());
    return manager->getNetToBBConnection(x.ref);
}


// *****************************************************************************
// getNetToBBConnection()
//
//
// *****************************************************************************
ModRef
ModGraph::getNetToBBConnection(oa::oaModBitNet *net) {
    Manager *manager = Manager::get(net->getDesign());
    return ModRef(manager->getNetToBBConnection(net), net->getModule());
}


// *****************************************************************************
// setNetToBBConnection()
//
//
// *****************************************************************************
void
ModGraph::setNetToBBConnection(oa::oaModBitNet *net, ModRef x) {
    failIfInDifferentModules(net->getModule(), x.module);

    Manager *manager = Manager::get(x.module->getDesign());
    manager->setNetToBBConnection(net, x.ref);
}

/*


// *****************************************************************************
// removeNetToBBConnection()
//
//
// *****************************************************************************
void
ModGraph::removeNetToBBConnection(oa::oaModBitNet *net) {
    Manager *manager = Manager::get(net->getDesign());
    manager->removeNetToBBConnection(net);
}

*/

// *****************************************************************************
// getOutputs()
//
//
// *****************************************************************************
void         
ModGraph::getOutputs(oa::oaModule *module, list<ModRef> &result) {
    assert(module);
    oa::oaModTerm *term;
    oa::oaIter<oa::oaModTerm> termIter(module->getTerms(oacTermIterSingleBit));
    while((term = termIter.getNext())) {
        if(term->getTermType() == oa::oacOutputTermType) {
            result.push_back(prepareNetToBBConnection(toBitNet(term->getNet())));
        }
    }
}

/*

// *****************************************************************************
// getInputs()
//
//
// *****************************************************************************
void         
ModGraph::getInputs(oa::oaModule *module, list<ModRef> &result) {
    assert(module);
    oa::oaModTerm *term;
    oa::oaIter<oa::oaModTerm> termIter(module->getTerms(oacTermIterSingleBit));
    while((term = termIter.getNext())) {
        if(term->getTermType() == oa::oacInputTermType) {
            result.push_back(prepareNetToAiConnection(toBitNet(term->getNet())));
        }
    }
}


// *****************************************************************************
// getAllNodes()
//
//
// *****************************************************************************
void         
ModGraph::getAllNodes(oa::oaModule *module, list<ModRef> &result) {
    assert(module);

    // add the state bits inside this object
    list<oagAi::Ref> flatResult;
    getGraph(module)->getAll(flatResult);
    convertRefListToModRefList(flatResult, module, result);

}


// *****************************************************************************
// getLocalStates()
//
//
// *****************************************************************************
void         
ModGraph::getLocalStates(oa::oaModule *module, list<ModRef> &result) {
    assert(module);

    // add the state bits inside this object
    list<oagAi::Ref> flatResult;
    getGraph(module)->getAllSequential(flatResult);
    convertRefListToModRefList(flatResult, module, result);
}


// *****************************************************************************
// getAllConnections()
//
//
// *****************************************************************************
void
ModGraph::getAllConnections(oa::oaModBitNet *net, 
                            set<oa::oaModBitNet*> &connectedNets,
                            set<ModRef> &connectedRefs,
                            bool searchForwardThroughGraph,
                            bool searchBackwardThroughGraph,
                            bool searchThroughEquivNets,
                            bool searchThroughEquivRefs,
                            bool includeSelf) {
    assert(net);
    
    // has this net been visited?
    if (connectedNets.find(net) == connectedNets.end()) {
        connectedNets.insert(net);
    } else {
        return;
    }

    // --- directly connected refs
    getAllConnections(getNetToAiConnection(net), connectedNets, connectedRefs,
                searchForwardThroughGraph, searchBackwardThroughGraph,
                searchThroughEquivNets, searchThroughEquivRefs, true);
    
    // --- equivalent nets (if searchThroughEquivNets)
    if (searchThroughEquivNets) {
        oa::oaModBitNet *equivNet;
        oa::oaIter<oa::oaModBitNet> equivIter(net->getEquivalentNets());
        while((equivNet = equivIter.getNext())) {
            getAllConnections(equivNet, connectedNets, connectedRefs,
                searchForwardThroughGraph, searchBackwardThroughGraph,
                searchThroughEquivNets, searchThroughEquivRefs, true);
        }
    }
    
    // -- exclude self
    if (!includeSelf) {
        connectedNets.erase(net);
    }
}


// *****************************************************************************
// getAllConnections()
//

//
// *****************************************************************************    
void 
ModGraph::getAllConnections(ModRef x, 
                            set<oa::oaModBitNet*> &connectedNets,
                            set<ModRef> &connectedRefs,
                            bool searchForwardThroughGraph,
                            bool searchBackwardThroughGraph,
                            bool searchThroughEquivNets,
                            bool searchThroughEquivRefs,
                            bool includeSelf) {
    if (isNull(x)) {
        return;
    }

    // has this ref been visited?
    if (connectedRefs.find(x) == connectedRefs.end()) {
        connectedRefs.insert(x);
    } else {
        return;
    }
    
    // --- directly connected nets
    if (isTerminal(x) && !isInverted(x)) {
        oa::oaModBitNet *net;
        if ((net = getNetToAiConnection(x))) {
            getAllConnections(net, connectedNets, connectedRefs,
                searchForwardThroughGraph, searchBackwardThroughGraph,
                searchThroughEquivNets, searchThroughEquivRefs, true);
        }
    }

    // --- connected backward through graph (if searchBackwardThroughGraph)
    if (searchBackwardThroughGraph) {
        // terminal drivers
        if (isTerminal(x)) {
            ModRef driver = getTerminalDriver(x);
            driver = isInverted(x) ? notOf(driver) : driver;
            getAllConnections(driver, connectedNets, connectedRefs,
                searchForwardThroughGraph, searchBackwardThroughGraph,
                searchThroughEquivNets, searchThroughEquivRefs, true);
        }
    }

    // --- connected forward through graph (if searchForwardThroughGraph)
    if (searchForwardThroughGraph) {
        // terminals in fanout
        list<ModRef> fanoutList;
        getFanout(x, fanoutList);
        while(!fanoutList.empty()) {
            ModRef fanout(fanoutList.front());
            fanoutList.pop_front();
            if(isTerminal(fanout)) {
                fanout = isInverted(x) ? notOf(fanout) : fanout;
                fanout = isInverted(getTerminalDriver(fanout)) ? notOf(fanout) : fanout;
                getAllConnections(fanout, connectedNets, connectedRefs,
                    searchForwardThroughGraph, searchBackwardThroughGraph,
                    searchThroughEquivNets, searchThroughEquivRefs, true);
            }
        }
    }

    // --- equivalent nodes (if searchThroughEquivRefs)
    if (searchThroughEquivRefs) {
        list<ModRef> equivList;
        getEquivalents(x, equivList);
        while(!equivList.empty()) {
            ModRef equiv(equivList.front());
            equivList.pop_front();
            getAllConnections(equiv, connectedNets, connectedRefs,
                searchForwardThroughGraph, searchBackwardThroughGraph,
                searchThroughEquivNets, searchThroughEquivRefs, true);
        }
    }
    
    // -- exclude self
    if (!includeSelf) {
        connectedRefs.erase(x);
    }
}
*/

// *****************************************************************************
// findDriverOfEquivalentNets()
//
//
// *****************************************************************************
oa::oaModBitNet *
ModGraph::findDriverOfEquivalentNets(oa::oaModBitNet *net) {
    assert(net);

    // ignore if there are no equivalent nets
    if (net->getEquivalentNets().isEmpty()) {
      return NULL;
    }

    // ignore if there is already a driver in the graph
    ModRef termRef = getNetToBBConnection(net);
    if (!isNull(termRef) && !isNull(getTerminalDriver(termRef))) {    
      return NULL;
    }

    // iterate over equivalent nets to find driver
    oa::oaModBitNet *equivNet;
    oa::oaIter<oa::oaModBitNet> equivNetIter(net->getEquivalentNets());

    DEBUG_PRINT("Equivalent set : ");
    while ((equivNet = equivNetIter.getNext())) {
      assert(equivNet);
      
      oa::oaString netString;
      equivNet->getName(oa::oaVerilogNS(), netString);
      DEBUG_PRINTMORE(netString << " ");

      // is this driven in the graph?
      ModRef termRef = getNetToBBConnection(equivNet);
      if (!isNull(termRef) && !isNull(getTerminalDriver(termRef))) {
        // avoid combinational cycles
        ModRef driverRef = termRef;
        while(true) {
          oa::oaModBitNet *net2 = getNetToBBConnection(driverRef);
          if (net2 && net2 == net) {
            // net can't be in a cycle with itself
            return NULL;
          }
          driverRef = getTerminalDriver(driverRef);
          if (isNull(driverRef) || !isTerminal(driverRef)) {
            break;
          }
        }
        return equivNet;
      }
      
      // is an input terminal attached?
      oa::oaModTerm *term;
      oa::oaIter<oa::oaModTerm> termIter(equivNet->getTerms(oacTermIterSingleBit));
      while((term = termIter.getNext())) {
        assert(term);
        if(term->getTermType() == oa::oacInputTermType) {
          return equivNet;
        }
      }
    }
    DEBUG_PRINTMORE("\n");
    
//    // is there a preferred equivalent?
//    
//    // NOTE: This appears to be broken.  A preferred net is sometimes
//    // returned when none has been set.  Reason unknown.
//
//    if (net->getPreferredEquivalent() != net) {
//      return net->getPreferredEquivalent();
//    }
    

    return NULL;
}


// *****************************************************************************
// connectEquivalentNetsInGraph()
//
// *****************************************************************************
void
ModGraph::connectEquivalentNetsInGraph(oa::oaModule *module) {
  assert(module);

  oa::oaModNet *net;
  oa::oaIter<oa::oaModNet> netIter(module->getNets(oacNetIterSingleBit));
  while((net = netIter.getNext())) {
    oa::oaModBitNet *bitNet = toBitNet(net);
    assert(bitNet);
    ModRef termNode = getNetToBBConnection(bitNet);
    assert(!isNull(termNode));
    if (!isNull(getTerminalDriver(termNode))) {
      continue;
    }

    oa::oaModBitNet *driverNet = findDriverOfEquivalentNets(bitNet);

    if (driverNet) {      
      ModRef driver = getNetToBBConnection(driverNet);
#if defined(DEBUG)
      cout << "Moving equivalent nets to graph : node ";
      termNode.printName(false);
      cout << " was ";
      getTerminalDriver(termNode).printName();
      cout << " is now driven by ";
      driver.printName(true);
      cout << endl;
#endif
      setTerminalDriver(termNode, driver);
    }
  }
}

/*
// *****************************************************************************
// print()
//
//
// *****************************************************************************
void                
ModGraph::print(oa::oaModule *module) {
  assert(module);

  list<ModRef> all;
  getAllNodes(module, all);
  for(list<ModRef>::iterator it = all.begin(); it!=all.end(); it++) {
    it->print();
  }
}


// *****************************************************************************
// print()
//
//
// *****************************************************************************
void                
ModRef::print(bool lineFeed) {
    const int TYPE_COL_WIDTH = 4;
    const int MODULE_COL_WIDTH = 20;
    const int REF_COL_WIDTH = 5;

    oa::oaString modString;
    if (!module) {
        modString = "(null)";
    } else {
        module->getName(oa::oaVerilogNS(), modString);
    }

    if (ModGraph::getNodeType(*this) == oagAi::Node::AND) {
        cout.width(TYPE_COL_WIDTH);
        cout << "AND ";
        cout.width(MODULE_COL_WIDTH);
        cout << modString << ".";
        cout.width(REF_COL_WIDTH);
        cout << ref << " :\t";
        cout << ModGraph::getAndLeft(*this).ref << ", " << ModGraph::getAndRight(*this).ref;
    } else if (ModGraph::getNodeType(*this) == oagAi::Node::SEQUENTIAL) {
        cout.width(TYPE_COL_WIDTH);
        cout << "SEQ ";
        cout.width(MODULE_COL_WIDTH);
        cout << modString << ".";
        cout.width(REF_COL_WIDTH);
        cout << ref << " :\t";
        cout << ModGraph::getNextState(*this).ref;
    } else if (ModGraph::getNodeType(*this) == oagAi::Node::CONSTANT0) {
        cout.width(TYPE_COL_WIDTH);
        cout << "ZRO ";
        cout.width(MODULE_COL_WIDTH);
        cout << modString << ".";
        cout.width(REF_COL_WIDTH);
        cout << ref << " :\t";
    } else if (ModGraph::getNodeType(*this) == oagAi::Node::TERMINAL) {
        cout.width(TYPE_COL_WIDTH);
        cout << "TRM ";
        cout.width(MODULE_COL_WIDTH);
        cout << modString << ".";
        cout.width(REF_COL_WIDTH);
        cout << ref << " :\t";
        cout << ModGraph::getTerminalDriver(*this).ref;
        cout << " net= ";
        oa::oaModBitNet *net = ModGraph::getNetToAiConnection(*this);
        if (net) {
          oa::oaString netString;
          net->getName(oa::oaVerilogNS(), netString);
          cout << netString;
        } else {
          cout << "*none*";
        }
    } else if (ModGraph::getNodeType(*this) == oagAi::Node::NONE) {
        cout.width(TYPE_COL_WIDTH);
        cout << "NUL ";
        cout.width(MODULE_COL_WIDTH);
        cout << modString << ".";
        cout.width(REF_COL_WIDTH);
        cout << ref << " :\t";
    }

    if (ModGraph::isInverted(*this)) {
        cout << " (inverted)";
    }
    
    if (lineFeed) {
        cout << endl;
    }
}

*/
// *****************************************************************************
// printName()
//
//
// *****************************************************************************
void                
ModRef::printName(bool lineFeed) {

    oa::oaString modString;
    if (!module) {
        modString = "(null)";
    } else {
        module->getName(oa::oaVerilogNS(), modString);
    }

    cout << modString << "." << ref;
    
    if (lineFeed) {
        cout << endl;
    }
}

/*
// *****************************************************************************
// getFaninCone()
//
//
// *****************************************************************************
void
ModGraph::getFaninCone(ModRef x, const list<ModRef> &coneRoots, 
                       list<ModRef> &transitiveFanin, bool includeRoots) {

  list<oagAi::Ref> flatCut;
  oa::oaModule *module = convertModRefListToRefList(coneRoots, flatCut);
  assert(coneRoots.empty() || module == x.module);
  list<oagAi::Ref> flatResult;
  getGraph(x.module)->getFaninCone(x.ref, flatCut, flatResult, includeRoots);
  convertRefListToModRefList(flatResult, x.module, transitiveFanin);
}


// *****************************************************************************
// getFanoutCone()
//
//
// *****************************************************************************
void
ModGraph::getFanoutCone(ModRef x, const list<ModRef> &coneRoots, 
                        list<ModRef> &transitiveFanout, bool includeRoots) {
  
  list<oagAi::Ref> flatCut;
  oa::oaModule *module = convertModRefListToRefList(coneRoots, flatCut);
  assert(module == x.module);
  list<oagAi::Ref> flatResult;
  getGraph(x.module)->getFanoutCone(x.ref, flatCut, flatResult, includeRoots);
  convertRefListToModRefList(flatResult, x.module, transitiveFanout);
}
*/

}

---