From: Chris Lattner <sabre@nondot.org>
Date: Thu, 7 Jun 2001 21:18:35 +0000 (+0000)
Subject: Moved iterators to the new CFG.h file.
X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=1f0d48113ca2077c8c6ea1a6d6039eb13623b732;p=oota-llvm.git

Moved iterators to the new CFG.h file.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14 91177308-0d34-0410-b5e6-96231b3b80d8
---

diff --git a/include/llvm/BasicBlock.h b/include/llvm/BasicBlock.h
index 5230e87d8df..0828e0777c0 100644
--- a/include/llvm/BasicBlock.h
+++ b/include/llvm/BasicBlock.h
@@ -24,8 +24,6 @@
 
 #include "llvm/Value.h"               // Get the definition of Value
 #include "llvm/ValueHolder.h"
-#include "llvm/InstrTypes.h"
-#include <list>
 
 class Instruction;
 class Method;
@@ -93,157 +91,6 @@ public:
   // the basic block).
   //
   BasicBlock *splitBasicBlock(InstListType::iterator I);
-
-  //===--------------------------------------------------------------------===//
-  // Predecessor iterator code
-  //===--------------------------------------------------------------------===//
-  // 
-  // This is used to figure out what basic blocks we could be coming from.
-  //
-
-  // Forward declare iterator class template...
-  template <class _Ptr, class _USE_iterator> class PredIterator;
-
-  typedef PredIterator<BasicBlock*, use_iterator> pred_iterator;
-  typedef PredIterator<const BasicBlock*, 
-                       use_const_iterator> pred_const_iterator;
-
-  inline pred_iterator       pred_begin()      ;
-  inline pred_const_iterator pred_begin() const;
-  inline pred_iterator       pred_end()        ;
-  inline pred_const_iterator pred_end()   const;
-
-  //===--------------------------------------------------------------------===//
-  // Successor iterator code
-  //===--------------------------------------------------------------------===//
-  // 
-  // This is used to figure out what basic blocks we could be going to...
-  //
-
-  // Forward declare iterator class template...
-  template <class _Term, class _BB> class SuccIterator;
-
-  typedef SuccIterator<TerminatorInst*, BasicBlock*> succ_iterator;
-  typedef SuccIterator<const TerminatorInst*, 
-		       const BasicBlock*> succ_const_iterator;
-
-  inline succ_iterator       succ_begin()      ;
-  inline succ_const_iterator succ_begin() const;
-  inline succ_iterator       succ_end()        ;
-  inline succ_const_iterator succ_end()   const;
-
-  //===--------------------------------------------------------------------===//
-  // END of interesting code...
-  //===--------------------------------------------------------------------===//
-  //
-  // Thank god C++ compilers are good at stomping out tons of templated code...
-  //
-  template <class _Ptr,  class _USE_iterator> // Predecessor Iterator
-  class PredIterator {
-    const _Ptr ThisBB;
-    _USE_iterator It;
-  public:
-    typedef PredIterator<_Ptr,_USE_iterator> _Self;
-
-    typedef bidirectional_iterator_tag iterator_category;
-    typedef _Ptr pointer;
-
-    inline void advancePastConstPool() {
-      // Loop to ignore constant pool references
-      while (It != ThisBB->use_end() && 
-	     ((*It)->getValueType() != Value::InstructionVal))
-	++It;
-    }
-
-    inline PredIterator(_Ptr BB) : ThisBB(BB), It(BB->use_begin()) {
-      advancePastConstPool();
-    }
-    inline PredIterator(_Ptr BB, bool) : ThisBB(BB), It(BB->use_end()) {}
-
-    inline bool operator==(const _Self& x) const { return It == x.It; }
-    inline bool operator!=(const _Self& x) const { return !operator==(x); }
-
-    inline pointer operator*() const { 
-      assert ((*It)->getValueType() == Value::InstructionVal);
-      return ((Instruction *)(*It))->getParent(); 
-    }
-    inline pointer *operator->() const { return &(operator*()); }
-
-    inline _Self& operator++() {   // Preincrement
-      ++It; advancePastConstPool();
-      return *this; 
-    }
-
-    inline _Self operator++(int) { // Postincrement
-      _Self tmp = *this; ++*this; return tmp; 
-    }
-
-    inline _Self& operator--() { --It; return *this; }  // Predecrement
-    inline _Self operator--(int) { // Postdecrement
-      _Self tmp = *this; --*this; return tmp;
-    }
-  };
-
-  template <class _Term, class _BB>           // Successor Iterator
-  class SuccIterator {
-    const _Term Term;
-    unsigned idx;
-  public:
-    typedef SuccIterator<_Term, _BB> _Self;
-    typedef forward_iterator_tag iterator_category;
-    typedef _BB pointer;
-    
-    inline SuccIterator(_Term T) : Term(T), idx(0) {}         // begin iterator
-    inline SuccIterator(_Term T, bool) 
-      : Term(T), idx(Term->getNumSuccessors()) {}             // end iterator
-    
-    inline bool operator==(const _Self& x) const { return idx == x.idx; }
-    inline bool operator!=(const _Self& x) const { return !operator==(x); }
-
-    inline pointer operator*() const { return Term->getSuccessor(idx); }
-    inline pointer *operator->() const { return &(operator*()); }
-    
-    inline _Self& operator++() { ++idx; return *this; } // Preincrement
-    inline _Self operator++(int) { // Postincrement
-      _Self tmp = *this; ++*this; return tmp; 
-    }
-
-    inline _Self& operator--() { --idx; return *this; }  // Predecrement
-    inline _Self operator--(int) { // Postdecrement
-      _Self tmp = *this; --*this; return tmp;
-    }
-  };
 };
 
-
-//===--------------------------------------------------------------------===//
-// Implement some stuff prototyped above...
-//===--------------------------------------------------------------------===//
-
-inline BasicBlock::pred_iterator       BasicBlock::pred_begin()       {
-  return pred_iterator(this);
-}
-inline BasicBlock::pred_const_iterator BasicBlock::pred_begin() const {
-  return pred_const_iterator(this);
-}
-inline BasicBlock::pred_iterator       BasicBlock::pred_end()         {
-  return pred_iterator(this,true);
-}
-inline BasicBlock::pred_const_iterator BasicBlock::pred_end()   const {
-  return pred_const_iterator(this,true);
-}
-
-inline BasicBlock::succ_iterator       BasicBlock::succ_begin()       {
-  return succ_iterator(getTerminator());
-}
-inline BasicBlock::succ_const_iterator BasicBlock::succ_begin() const {
-  return succ_const_iterator(getTerminator());
-}
-inline BasicBlock::succ_iterator       BasicBlock::succ_end()         {
-  return succ_iterator(getTerminator(),true);
-}
-inline BasicBlock::succ_const_iterator BasicBlock::succ_end()   const {
-  return succ_const_iterator(getTerminator(),true);
-}
-
 #endif