[llvm-commits] CVS: llvm/include/llvm/Analysis/ConstantsScanner.h IntervalIterator.h Verifier.h

[Misha Brukman]

Changes in directory llvm/include/llvm/Analysis:

ConstantsScanner.h updated: 1.16 -> 1.17
IntervalIterator.h updated: 1.21 -> 1.22
Verifier.h updated: 1.14 -> 1.15
---
Log message:

Convert tabs to spaces


---
Diffs of the changes:  (+25 -25)

 ConstantsScanner.h |    8 ++++----
 IntervalIterator.h |   40 ++++++++++++++++++++--------------------
 Verifier.h         |    2 +-
 3 files changed, 25 insertions(+), 25 deletions(-)


Index: llvm/include/llvm/Analysis/ConstantsScanner.h
diff -u llvm/include/llvm/Analysis/ConstantsScanner.h:1.16 llvm/include/llvm/Analysis/ConstantsScanner.h:1.17
--- llvm/include/llvm/Analysis/ConstantsScanner.h:1.16	Thu Apr 21 15:16:31 2005
+++ llvm/include/llvm/Analysis/ConstantsScanner.h	Thu Apr 21 22:25:27 2005
@@ -32,7 +32,7 @@
 
   inline bool isAtConstant() const {
     assert(!InstI.atEnd() && OpIdx < InstI->getNumOperands() &&
-	   "isAtConstant called with invalid arguments!");
+           "isAtConstant called with invalid arguments!");
     return isa<Constant>(InstI->getOperand(OpIdx));
   }
 
@@ -40,7 +40,7 @@
   inline constant_iterator(const Function *F) : InstI(inst_begin(F)), OpIdx(0) {
     // Advance to first constant... if we are not already at constant or end
     if (InstI != inst_end(F) &&                            // InstI is valid?
-	(InstI->getNumOperands() == 0 || !isAtConstant())) // Not at constant?
+        (InstI->getNumOperands() == 0 || !isAtConstant())) // Not at constant?
       operator++();
   }
 
@@ -49,7 +49,7 @@
   }
 
   inline bool operator==(const _Self& x) const { return OpIdx == x.OpIdx &&
-						        InstI == x.InstI; }
+                                                        InstI == x.InstI; }
   inline bool operator!=(const _Self& x) const { return !operator==(x); }
 
   inline pointer operator*() const {
@@ -63,7 +63,7 @@
     do {
       unsigned NumOperands = InstI->getNumOperands();
       while (OpIdx < NumOperands && !isAtConstant()) {
-	++OpIdx;
+        ++OpIdx;
       }
 
       if (OpIdx < NumOperands) return *this;  // Found a constant!


Index: llvm/include/llvm/Analysis/IntervalIterator.h
diff -u llvm/include/llvm/Analysis/IntervalIterator.h:1.21 llvm/include/llvm/Analysis/IntervalIterator.h:1.22
--- llvm/include/llvm/Analysis/IntervalIterator.h:1.21	Thu Apr 21 15:16:32 2005
+++ llvm/include/llvm/Analysis/IntervalIterator.h	Thu Apr 21 22:25:27 2005
@@ -115,8 +115,8 @@
   inline ~IntervalIterator() {
     if (IOwnMem)
       while (!IntStack.empty()) {
-	delete operator*();
-	IntStack.pop();
+        delete operator*();
+        IntStack.pop();
       }
   }
 
@@ -134,11 +134,11 @@
       // All of the intervals on the stack have been visited.  Try visiting
       // their successors now.
       Interval::succ_iterator &SuccIt = IntStack.top().second,
-	                        EndIt = succ_end(IntStack.top().first);
+                                EndIt = succ_end(IntStack.top().first);
       while (SuccIt != EndIt) {                 // Loop over all interval succs
-	bool Done = ProcessInterval(getSourceGraphNode(OrigContainer, *SuccIt));
-	++SuccIt;                               // Increment iterator
-	if (Done) return *this;                 // Found a new interval! Use it!
+        bool Done = ProcessInterval(getSourceGraphNode(OrigContainer, *SuccIt));
+        ++SuccIt;                               // Increment iterator
+        if (Done) return *this;                 // Found a new interval! Use it!
       }
 
       // Free interval memory... if necessary
@@ -196,19 +196,19 @@
 
     if (Visited.count(NodeHeader)) {     // Node already been visited?
       if (Int->contains(NodeHeader)) {   // Already in this interval...
-	return;
+        return;
       } else {                           // In other interval, add as successor
-	if (!Int->isSuccessor(NodeHeader)) // Add only if not already in set
-	  Int->Successors.push_back(NodeHeader);
+        if (!Int->isSuccessor(NodeHeader)) // Add only if not already in set
+          Int->Successors.push_back(NodeHeader);
       }
     } else {                             // Otherwise, not in interval yet
       for (typename IGT::ChildIteratorType I = IGT::child_begin(Node),
              E = IGT::child_end(Node); I != E; ++I) {
-	if (!Int->contains(*I)) {        // If pred not in interval, we can't be
-	  if (!Int->isSuccessor(NodeHeader)) // Add only if not already in set
-	    Int->Successors.push_back(NodeHeader);
-	  return;                        // See you later
-	}
+        if (!Int->contains(*I)) {        // If pred not in interval, we can't be
+          if (!Int->isSuccessor(NodeHeader)) // Add only if not already in set
+            Int->Successors.push_back(NodeHeader);
+          return;                        // See you later
+        }
       }
 
       // If we get here, then all of the predecessors of BB are in the interval
@@ -217,17 +217,17 @@
       Visited.insert(NodeHeader);     // The node has now been visited!
 
       if (Int->isSuccessor(NodeHeader)) {
-	// If we were in the successor list from before... remove from succ list
-	Int->Successors.erase(std::remove(Int->Successors.begin(),
-				          Int->Successors.end(), NodeHeader),
-			      Int->Successors.end());
+        // If we were in the successor list from before... remove from succ list
+        Int->Successors.erase(std::remove(Int->Successors.begin(),
+                                          Int->Successors.end(), NodeHeader),
+                              Int->Successors.end());
       }
 
       // Now that we have discovered that Node is in the interval, perhaps some
       // of its successors are as well?
       for (typename GT::ChildIteratorType It = GT::child_begin(Node),
-	     End = GT::child_end(Node); It != End; ++It)
-	ProcessNode(Int, getSourceGraphNode(OrigContainer, *It));
+             End = GT::child_end(Node); It != End; ++It)
+        ProcessNode(Int, getSourceGraphNode(OrigContainer, *It));
     }
   }
 };


Index: llvm/include/llvm/Analysis/Verifier.h
diff -u llvm/include/llvm/Analysis/Verifier.h:1.14 llvm/include/llvm/Analysis/Verifier.h:1.15
--- llvm/include/llvm/Analysis/Verifier.h:1.14	Thu Apr 21 15:16:32 2005
+++ llvm/include/llvm/Analysis/Verifier.h	Thu Apr 21 22:25:27 2005
@@ -37,7 +37,7 @@
   AbortProcessAction,   ///< verifyModule will print to stderr and abort()
   ThrowExceptionAction, ///< verifyModule will throw errors as std::string
   PrintMessageAction,   ///< verifyModule will print to stderr and return true
-  ReturnStatusAction 	///< verifyModule will just return true
+  ReturnStatusAction    ///< verifyModule will just return true
 };
 
 /// @brief Create a verifier pass.