C++ ListIterator::getNext方法代码示例

void
TR_ExpressionsSimplification::removeUncertainBlocks(TR_RegionStructure* region, List<TR::Block> *candidateBlocksList)
   {
   // Examine the top region block first
   //
   TR::Block *entryBlock = _currentRegion->getEntryBlock();
   ListIterator<TR::Block> blocks;
   blocks.set(candidateBlocksList);

   if (trace())
      traceMsg(comp(), "Number of blocks %d, entry block number %d\n", candidateBlocksList->getSize(), entryBlock->getNumber());

   for (TR::Block *block = blocks.getFirst(); block; block = blocks.getNext())
      {
      TR::CFGNode *cfgNode = block;
      if (!(cfgNode->getExceptionSuccessors().empty()) || blockHasCalls(block, comp()))
         {
         if (trace())
            traceMsg(comp(), "An exception can be thrown from block_%d. Removing all the blocks, since we cannot know the number of iterations.\n", block->getNumber());
         candidateBlocksList->deleteAll();
         break;
         }
      }

   TR_PostDominators postDominators(comp());
   if (postDominators.isValid())
      {
	  postDominators.findControlDependents();
      for (TR::Block *block = blocks.getFirst(); block; block = blocks.getNext())
         {
         if (postDominators.dominates(block, entryBlock) == 0)
            {
            candidateBlocksList->remove(block);
            if (trace())
               traceMsg(comp(), "Block_%d is not guaranteed to be executed at least once. Removing it from the list.\n", block->getNumber());
            }
         }
      }
   else
      {
	  if (trace())
	     traceMsg(comp(), "There is no post dominators information. Removing all the blocks.\n");
	  for (TR::Block *block = blocks.getFirst(); block; block = blocks.getNext())
	     {
	     candidateBlocksList->remove(block);
	     if (trace())
	        traceMsg(comp(), "Block_%d is removed from the list\n", block->getNumber());
	     }
      }
   }

//
// Print the group information into the cfg file.
//
bool PanelGroupManager::cfgPrintComment(FILE *f)
{
    int	  i, inst;
    List  plist;
    ListIterator li;
    char  *name;

    for(i=1; (name = (char*)this->getPanelGroup(i, &plist)); i++)
    {
        if (fprintf(f, "// panel group: \"%s\"", name) < 0)
            return false;

        li.setList(plist);

        while( (inst = (int)(long)li.getNext()) )
            if (fprintf(f, " %d", inst-1) < 0)
                return false;

        if (fputc('\n', f) < 0)
            return false;

        plist.clear();
    }

    return true;
}

PageSelector::~PageSelector()
{
    if (this->page_buttons) {
	// The superclass destructor calls clear() but I'm confused
	// about what the virtual call from the destructor is going
	// to do.  So I'll add the needed statements.
	ListIterator it (*this->page_buttons);
	PageTab* page_button;
	while ( (page_button = (PageTab*)it.getNext()) ) {
	    page_button->unmanage();
	    delete page_button;
	}
	delete this->page_buttons;
	this->page_buttons = NUL(List*);
    }

boolean
MacroParameterNode::canCoerceValue (const char* option, List* types)
{
	ListIterator iter;
	boolean coerced = FALSE;
	DXType* dxtype;
	for (iter.setList(*types) ; (dxtype = (DXType*)iter.getNext()) ; ) {
		char* s = DXValue::CoerceValue (option, dxtype->getType());
		if (s) {
			coerced = TRUE;
			delete s;
			break;
		}
	}
	return coerced;
}

boolean MacroParameterNode::removeIOArk(List *io, int index, Ark *a)
{
    int destIndex;
    int srcIndex;
    Node* destinationNode = a->getDestinationNode(destIndex);
    Node* sourceNode = a->getSourceNode(srcIndex);
    NodeDefinition* destinationDefinition = destinationNode->getDefinition();
    if (!this->UniqueNameNode::removeIOArk(io, index, a))
	return FALSE;

    ParameterDefinition *macroPd = this->getParameterDefinition();

    //
    // During deletion of a MacroDefinition, there is no MacroDefinition
    // for this node and therefore no ParameterDefinition.  So just return.
    //
    if (!macroPd)
	return TRUE;

    Parameter *pout;
    if (this->isInput())
	pout = this->getOutputParameter(1);
    else
	pout = this->getInputParameter(1);

    ParameterDefinition *nodePd = pout->getDefinition();

    List *outTypes = macroPd->getTypes();
    DXType *t;
    while( (t = (DXType*)(outTypes->getElement(1))) )
    {
	macroPd->removeType(t);
    }

    outTypes = nodePd->getTypes();
    while( (t = (DXType*)(outTypes->getElement(1))) )
    {
	nodePd->removeType(t);
    }

    // for each arc connected to this, intersect this type
    // list with "typesList" and set this to be the current types list.
    const List *arcs;
    if (this->isInput())
	arcs = this->getOutputArks(srcIndex);
    else
	arcs = this->getInputArks(destIndex);
    

    ListIterator li;
    li.setList(*(List *)arcs);

    List *typesList = new List;
    typesList->appendElement(new DXType(DXType::ObjectType));

    while( (a = (Ark*)li.getNext()) )
    {
	ParameterDefinition *pind;
	if (this->isInput())
	{
	    int dummy;
	    Node *dest = a->getDestinationNode(dummy);
	    pind = ((MacroParameterNode*)dest)->getInputParameter(dummy)->
				    getDefinition();
	}
	else
	{
	    int dummy;
	    Node *dest = a->getSourceNode(dummy);
	    pind = ((MacroParameterNode*)dest)->getOutputParameter(dummy)->
				    getDefinition();
	}
	List *newTypesList = DXType::IntersectTypeLists(
	    *typesList,
	    *pind->getTypes());
	// FIXME:  don't you have to delete the items in the list first?
	delete typesList;
	typesList = newTypesList;
    }


    li.setList(*typesList);
    while( (t = (DXType*)li.getNext()) )
    {
	DXType *newt = t->duplicate(); 
	nodePd->addType(newt);
	macroPd->addType(t);
    }
    delete typesList;

    if (this->isInput()) {
	const char *const *dest_option_vals;
	const char *const *src_option_vals;
	// If our current option values are equal to the options
	// values at the other end of the ark that we're disconnecting,
	// then assume that our option values came over this ark, and
	// toss ours out.  This prevents us from discarding a user's input.
	boolean we_disconnected_the_one = FALSE;

	ParameterDefinition *dpd = destinationDefinition->getInputDefinition(destIndex);
//.........这里部分代码省略.........

//
// When a Receiver gets a new label, it has to disconnect from its existing
// transmitter, and connect to the new one.  This will work even if it's
// the transmitter that's changing our label.
boolean ReceiverNode::setLabelString(const char *label)
{
    if (EqualString(label, this->getLabelString()))
        return TRUE;

    if (initializing && this->getNetwork()->isReadingNetwork())
        return this->UniqueNameNode::setLabelString(label);

    if (!this->verifyRestrictedLabel(label))
        return FALSE;

    //
    // Skip the conflict check when reading in a newer style net since
    // there can't be any conflict in these nets.
    //
    const char* conflict = NUL(char*);
    if (this->getNetwork()->isReadingNetwork()) {
        int net_major = this->getNetwork()->getNetMajorVersion();
        int net_minor = this->getNetwork()->getNetMinorVersion();
        int net_micro = this->getNetwork()->getNetMicroVersion();
        int net_version =   VERSION_NUMBER( net_major, net_minor, net_micro);
        if (net_version < VERSION_NUMBER(3,1,1))
            conflict = this->getNetwork()->nameConflictExists(this, label);
    }

    //
    // If there is a name conflict while reading a network, it's important to try
    // to continue in spite of the conflict and fix things up later.  Reason: older
    // versions of dx allowed the name conflict and we would like to try and fix
    // things and report what happened rather than read the net incorrectly.
    //
    if ((conflict) && (this->getNetwork()->isReadingNetwork() == FALSE)) {
        ErrorMessage("A %s with name \"%s\" already exists.", conflict, label);
        return FALSE;
    }

    boolean found = FALSE;
    List *ia = (List*)this->getInputArks(1);
    if ((ia) && (ia->getSize() > 0)) {
        Ark *a = (Ark*)ia->getElement(1);
        int dummy;
        if (EqualString(a->getSourceNode(dummy)->getLabelString(), label))
            found = TRUE;
        else
            delete a;
    }
    ia = NUL(List*);


    if (!found) {
        List* l = this->getNetwork()->makeClassifiedNodeList(ClassTransmitterNode, FALSE);
        ListIterator iterator;
        Node *n;

        if ((l) && (this->getNetwork()->isReadingNetwork() == FALSE)) {
            //
            // Before creating any Arks, check for cycles.
            //
            iterator.setList(*l);
            while ( (n = (Node*)iterator.getNext()) ) {
                if (EqualString(label, n->getLabelString())) {
                    Network* net = this->getNetwork();
                    if (net->checkForCycle(n, this)) {
                        ErrorMessage (
                            "Unable to rename Receiver \"%s\" to \"%s\"\n"
                            "because that would cause a cyclic connection.",
                            this->getLabelString(), label
                        );
                        delete l;
                        return FALSE;
                    }
                }
            }
        }

        if (l) {
            iterator.setList(*l);
            while ( (n = (Node*)iterator.getNext()) ) {
                if (EqualString(label, n->getLabelString()))
                {
                    found = TRUE;
                    // link me to transmitter
                    new Ark(n, 1, this, 1);
                }
            }
            delete l;
        }
    }

    //
    // There was a name conflict because earlier versions of dx were less restrictive.
    // Record the transmitter for later fixup.  When the transmitter is fixed up,
    // then we'll automatically get fixed up also.  Caveat:  if there is no transmitter
    // connected, then it's cool to refuse the name because then we're not breaking
    // anything.
    //
//.........这里部分代码省略.........

void TR_ExpressionsSimplification::simplifyInvariantLoopExpressions(ListIterator<TR::Block> &blocks)
   {
   // Need to locate the induction variable of the loop
   //
   LoopInfo *loopInfo = findLoopInfo(_currentRegion);

   if (trace())
      {
      if (!loopInfo)
         {
         traceMsg(comp(), "Accurate loop info is not found, cannot carry out summation reduction\n");
         }
      else
         {
         traceMsg(comp(), "Accurate loop info has been found, will try to carry out summation reduction\n");
         if (loopInfo->getBoundaryNode())
            {
            traceMsg(comp(), "Variable iterations from node %p has not been handled\n",loopInfo->getBoundaryNode());
            }
         else
            {
            traceMsg(comp(), "Natural Loop %p will run %d times\n", _currentRegion, loopInfo->getNumIterations());
            }
         }
      }

   // Initialize the list of candidates
   //
   _candidateTTs = new (trStackMemory()) TR_ScratchList<TR::TreeTop>(trMemory());

   for (TR::Block *currentBlock = blocks.getFirst(); currentBlock; currentBlock  = blocks.getNext())
      {
      if (trace())
         traceMsg(comp(), "Analyzing block #%d, which must be executed once per iteration\n", currentBlock->getNumber());


      // Scan through each node in the block
      //
      TR::TreeTop *tt = currentBlock->getEntry();
      TR::TreeTop *exitTreeTop = currentBlock->getExit();
      while (tt != exitTreeTop)
         {
         TR::Node *currentNode = tt->getNode();
         if (trace())
            traceMsg(comp(), "Analyzing tree top node %p\n", currentNode);

         if (loopInfo)
            {
            // requires loop info for the number of iterations
            setSummationReductionCandidates(currentNode, tt);
            }
         setStoreMotionCandidates(currentNode, tt);

         tt = tt->getNextTreeTop();
         }
      }

   // New code: without using any UDI
   // walk through the trees in the loop
   // to invalidate the candidates
   //
   if (!_supportedExpressions)
      {
      _supportedExpressions = new (trStackMemory()) TR_BitVector(comp()->getNodeCount(), trMemory(), stackAlloc, growable);
      }

   invalidateCandidates();

   ListIterator<TR::TreeTop> treeTops(_candidateTTs);
   for (TR::TreeTop *treeTop = treeTops.getFirst(); treeTop; treeTop = treeTops.getNext())
      {
      if (trace())
         traceMsg(comp(), "Candidate TreeTop: %p, Node:%p\n", treeTop, treeTop->getNode());

      bool usedCandidate = false;
      bool isPreheaderBlockInvalid = false;

      if (loopInfo)
         {
         usedCandidate = tranformSummationReductionCandidate(treeTop, loopInfo, &isPreheaderBlockInvalid);
         }

      if (isPreheaderBlockInvalid)
         {
         break;
         }

      if (!usedCandidate)
         {
         tranformStoreMotionCandidate(treeTop, &isPreheaderBlockInvalid);
         }
      if (isPreheaderBlockInvalid)
         {
         break;
         }
      }
   }