Removed trailing whitespace.

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

include/llvm/ADT/SmallVector.h

@@ -54,7 +54,7 @@ template <typename T>
 class SmallVectorImpl {
 protected:
   T *Begin, *End, *Capacity;
-  
+
   // Allocate raw space for N elements of type T.  If T has a ctor or dtor, we
   // don't want it to be automatically run, so we need to represent the space as
   // something else.  An array of char would work great, but might not be
@@ -76,11 +76,11 @@ protected:
 public:
   // Default ctor - Initialize to empty.
   SmallVectorImpl(unsigned N)
-    : Begin(reinterpret_cast<T*>(&FirstEl)), 
-      End(reinterpret_cast<T*>(&FirstEl)), 
+    : Begin(reinterpret_cast<T*>(&FirstEl)),
+      End(reinterpret_cast<T*>(&FirstEl)),
       Capacity(reinterpret_cast<T*>(&FirstEl)+N) {
   }
-  
+
   ~SmallVectorImpl() {
     // Destroy the constructed elements in the vector.
     destroy_range(Begin, End);
@@ -89,16 +89,16 @@ public:
     if (!isSmall())
       operator delete(Begin);
   }
-  
+
   typedef size_t size_type;
   typedef ptrdiff_t difference_type;
   typedef T value_type;
   typedef T* iterator;
   typedef const T* const_iterator;
-  
+
   typedef std::reverse_iterator<const_iterator>  const_reverse_iterator;
   typedef std::reverse_iterator<iterator>  reverse_iterator;
-  
+
   typedef T& reference;
   typedef const T& const_reference;
   typedef T* pointer;
@@ -113,14 +113,14 @@ public:
   const_iterator begin() const { return Begin; }
   iterator end() { return End; }
   const_iterator end() const { return End; }
-  
+
   // reverse iterator creation methods.
   reverse_iterator rbegin()            { return reverse_iterator(end()); }
   const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
   reverse_iterator rend()              { return reverse_iterator(begin()); }
   const_reverse_iterator rend() const { return const_reverse_iterator(begin());}
-  
-  
+
+
   /* These asserts could be "Begin + idx < End", but there are lots of places
      in llvm where we use &v[v.size()] instead of v.end(). */
   reference operator[](unsigned idx) {
@@ -131,21 +131,21 @@ public:
     assert (Begin + idx <= End);
     return Begin[idx];
   }
-  
+
   reference front() {
     return begin()[0];
   }
   const_reference front() const {
     return begin()[0];
   }
-  
+
   reference back() {
     return end()[-1];
   }
   const_reference back() const {
     return end()[-1];
   }
-  
+
   void push_back(const_reference Elt) {
     if (End < Capacity) {
   Retry:
@@ -156,23 +156,23 @@ public:
     grow();
     goto Retry;
   }
-  
+
   void pop_back() {
     --End;
     End->~T();
   }
-  
+
   T pop_back_val() {
     T Result = back();
     pop_back();
     return Result;
   }
-  
+
   void clear() {
     destroy_range(Begin, End);
     End = Begin;
   }
-  
+
   void resize(unsigned N) {
     if (N < size()) {
       destroy_range(Begin+N, End);
@@ -184,7 +184,7 @@ public:
       End = Begin+N;
     }
   }
-  
+
   void resize(unsigned N, const T &NV) {
     if (N < size()) {
       destroy_range(Begin+N, End);
@@ -196,14 +196,14 @@ public:
       End = Begin+N;
     }
   }
-  
+
   void reserve(unsigned N) {
     if (unsigned(Capacity-Begin) < N)
       grow(N);
   }
-  
+
   void swap(SmallVectorImpl &RHS);
-  
+
   /// append - Add the specified range to the end of the SmallVector.
   ///
   template<typename in_iter>
@@ -217,7 +217,7 @@ public:
     std::uninitialized_copy(in_start, in_end, End);
     End += NumInputs;
   }
-  
+
   /// append - Add the specified range to the end of the SmallVector.
   ///
   void append(size_type NumInputs, const T &Elt) {
@@ -229,7 +229,7 @@ public:
     std::uninitialized_fill_n(End, NumInputs, Elt);
     End += NumInputs;
   }
-  
+
   void assign(unsigned NumElts, const T &Elt) {
     clear();
     if (unsigned(Capacity-Begin) < NumElts)
@@ -237,7 +237,7 @@ public:
     End = Begin+NumElts;
     construct_range(Begin, End, Elt);
   }
-  
+
   iterator erase(iterator I) {
     iterator N = I;
     // Shift all elts down one.
@@ -246,7 +246,7 @@ public:
     pop_back();
     return(N);
   }
-  
+
   iterator erase(iterator S, iterator E) {
     iterator N = S;
     // Shift all elts down.
@@ -256,13 +256,13 @@ public:
     End = I;
     return(N);
   }
-  
+
   iterator insert(iterator I, const T &Elt) {
     if (I == End) {  // Important special case for empty vector.
       push_back(Elt);
       return end()-1;
     }
-    
+
     if (End < Capacity) {
   Retry:
       new (End) T(back());
@@ -283,100 +283,100 @@ public:
       append(NumToInsert, Elt);
       return end()-1;
     }
-    
+
     // Convert iterator to elt# to avoid invalidating iterator when we reserve()
     size_t InsertElt = I-begin();
-    
+
     // Ensure there is enough space.
     reserve(static_cast<unsigned>(size() + NumToInsert));
-    
+
     // Uninvalidate the iterator.
     I = begin()+InsertElt;
-    
+
     // If we already have this many elements in the collection, append the
     // dest elements at the end, then copy over the appropriate elements.  Since
     // we already reserved space, we know that this won't reallocate the vector.
     if (size() >= NumToInsert) {
       T *OldEnd = End;
       append(End-NumToInsert, End);
-      
+
       // Copy the existing elements that get replaced.
       std::copy(I, OldEnd-NumToInsert, I+NumToInsert);
-      
+
       std::fill_n(I, NumToInsert, Elt);
       return I;
     }
 
     // Otherwise, we're inserting more elements than exist already, and we're
     // not inserting at the end.
-    
+
     // Copy over the elements that we're about to overwrite.
     T *OldEnd = End;
     End += NumToInsert;
     size_t NumOverwritten = OldEnd-I;
     std::uninitialized_copy(I, OldEnd, End-NumOverwritten);
-    
+
     // Replace the overwritten part.
     std::fill_n(I, NumOverwritten, Elt);
-    
+
     // Insert the non-overwritten middle part.
     std::uninitialized_fill_n(OldEnd, NumToInsert-NumOverwritten, Elt);
     return I;
   }
-  
+
   template<typename ItTy>
   iterator insert(iterator I, ItTy From, ItTy To) {
     if (I == End) {  // Important special case for empty vector.
       append(From, To);
       return end()-1;
     }
-    
+
     size_t NumToInsert = std::distance(From, To);
     // Convert iterator to elt# to avoid invalidating iterator when we reserve()
     size_t InsertElt = I-begin();
-    
+
     // Ensure there is enough space.
     reserve(static_cast<unsigned>(size() + NumToInsert));
-    
+
     // Uninvalidate the iterator.
     I = begin()+InsertElt;
-    
+
     // If we already have this many elements in the collection, append the
     // dest elements at the end, then copy over the appropriate elements.  Since
     // we already reserved space, we know that this won't reallocate the vector.
     if (size() >= NumToInsert) {
       T *OldEnd = End;
       append(End-NumToInsert, End);
-      
+
       // Copy the existing elements that get replaced.
       std::copy(I, OldEnd-NumToInsert, I+NumToInsert);
-      
+
       std::copy(From, To, I);
       return I;
     }
 
     // Otherwise, we're inserting more elements than exist already, and we're
     // not inserting at the end.
-    
+
     // Copy over the elements that we're about to overwrite.
     T *OldEnd = End;
     End += NumToInsert;
     size_t NumOverwritten = OldEnd-I;
     std::uninitialized_copy(I, OldEnd, End-NumOverwritten);
-    
+
     // Replace the overwritten part.
     std::copy(From, From+NumOverwritten, I);
-    
+
     // Insert the non-overwritten middle part.
     std::uninitialized_copy(From+NumOverwritten, To, OldEnd);
     return I;
   }
-  
+
   const SmallVectorImpl &operator=(const SmallVectorImpl &RHS);
-  
+
   bool operator==(const SmallVectorImpl &RHS) const {
     if (size() != RHS.size()) return false;
-    for (T *This = Begin, *That = RHS.Begin, *E = Begin+size(); 
+    for (T *This = Begin, *That = RHS.Begin, *E = Begin+size();
          This != E; ++This, ++That)
       if (*This != *That)
         return false;
@@ -388,12 +388,12 @@ public:
     return std::lexicographical_compare(begin(), end(),
                                         RHS.begin(), RHS.end());
   }
-  
+
 private:
   /// isSmall - Return true if this is a smallvector which has not had dynamic
   /// memory allocated for it.
   bool isSmall() const {
-    return static_cast<const void*>(Begin) == 
+    return static_cast<const void*>(Begin) ==
            static_cast<const void*>(&FirstEl);
   }
 
@@ -405,7 +405,7 @@ private:
     for (; S != E; ++S)
       new (S) T(Elt);
   }
-  
+
   void destroy_range(T *S, T *E) {
     while (S != E) {
       --E;
@@ -423,21 +423,21 @@ void SmallVectorImpl<T>::grow(size_t MinSize) {
   if (NewCapacity < MinSize)
     NewCapacity = MinSize;
   T *NewElts = static_cast<T*>(operator new(NewCapacity*sizeof(T)));
-  
+
   // Copy the elements over.
   if (is_class<T>::value)
     std::uninitialized_copy(Begin, End, NewElts);
   else
     // Use memcpy for PODs (std::uninitialized_copy optimizes to memmove).
     memcpy(NewElts, Begin, CurSize * sizeof(T));
-  
+
   // Destroy the original elements.
   destroy_range(Begin, End);
-  
+
   // If this wasn't grown from the inline copy, deallocate the old space.
   if (!isSmall())
     operator delete(Begin);
-  
+
   Begin = NewElts;
   End = NewElts+CurSize;
   Capacity = Begin+NewCapacity;
@@ -446,7 +446,7 @@ void SmallVectorImpl<T>::grow(size_t MinSize) {
 template <typename T>
 void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
   if (this == &RHS) return;
-  
+
   // We can only avoid copying elements if neither vector is small.
   if (!isSmall() && !RHS.isSmall()) {
     std::swap(Begin, RHS.Begin);
@@ -458,13 +458,13 @@ void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
     grow(RHS.size());
   if (RHS.begin()+size() > RHS.Capacity)
     RHS.grow(size());
-  
+
   // Swap the shared elements.
   size_t NumShared = size();
   if (NumShared > RHS.size()) NumShared = RHS.size();
   for (unsigned i = 0; i != static_cast<unsigned>(NumShared); ++i)
     std::swap(Begin[i], RHS[i]);
-  
+
   // Copy over the extra elts.
   if (size() > RHS.size()) {
     size_t EltDiff = size() - RHS.size();
@@ -480,13 +480,13 @@ void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
     RHS.End = RHS.Begin+NumShared;
   }
 }
-  
+
 template <typename T>
 const SmallVectorImpl<T> &
 SmallVectorImpl<T>::operator=(const SmallVectorImpl<T> &RHS) {
   // Avoid self-assignment.
   if (this == &RHS) return *this;
-  
+
   // If we already have sufficient space, assign the common elements, then
   // destroy any excess.
   unsigned RHSSize = unsigned(RHS.size());
@@ -498,15 +498,15 @@ SmallVectorImpl<T>::operator=(const SmallVectorImpl<T> &RHS) {
       NewEnd = std::copy(RHS.Begin, RHS.Begin+RHSSize, Begin);
     else
       NewEnd = Begin;
-    
+
     // Destroy excess elements.
     destroy_range(NewEnd, End);
-    
+
     // Trim.
     End = NewEnd;
     return *this;
   }
-  
+
   // If we have to grow to have enough elements, destroy the current elements.
   // This allows us to avoid copying them during the grow.
   if (unsigned(Capacity-Begin) < RHSSize) {
@@ -519,15 +519,15 @@ SmallVectorImpl<T>::operator=(const SmallVectorImpl<T> &RHS) {
     // Otherwise, use assignment for the already-constructed elements.
     std::copy(RHS.Begin, RHS.Begin+CurSize, Begin);
   }
-  
+
   // Copy construct the new elements in place.
   std::uninitialized_copy(RHS.Begin+CurSize, RHS.End, Begin+CurSize);
-  
+
   // Set end.
   End = Begin+RHSSize;
   return *this;
 }
-  
+
 /// SmallVector - This is a 'vector' (really, a variable-sized array), optimized
 /// for the case when the array is small.  It contains some number of elements
 /// in-place, which allows it to avoid heap allocation when the actual number of
@@ -544,36 +544,36 @@ class SmallVector : public SmallVectorImpl<T> {
   enum {
     // MinUs - The number of U's require to cover N T's.
     MinUs = (static_cast<unsigned int>(sizeof(T))*N +
-             static_cast<unsigned int>(sizeof(U)) - 1) / 
+             static_cast<unsigned int>(sizeof(U)) - 1) /
             static_cast<unsigned int>(sizeof(U)),
-    
+
     // NumInlineEltsElts - The number of elements actually in this array.  There
     // is already one in the parent class, and we have to round up to avoid
     // having a zero-element array.
     NumInlineEltsElts = MinUs > 1 ? (MinUs - 1) : 1,
-    
+
     // NumTsAvailable - The number of T's we actually have space for, which may
     // be more than N due to rounding.
     NumTsAvailable = (NumInlineEltsElts+1)*static_cast<unsigned int>(sizeof(U))/
                      static_cast<unsigned int>(sizeof(T))
   };
   U InlineElts[NumInlineEltsElts];
-public:  
+public:
   SmallVector() : SmallVectorImpl<T>(NumTsAvailable) {
   }
-  
+
   explicit SmallVector(unsigned Size, const T &Value = T())
     : SmallVectorImpl<T>(NumTsAvailable) {
     this->reserve(Size);
     while (Size--)
       this->push_back(Value);
   }
-  
+
   template<typename ItTy>
   SmallVector(ItTy S, ItTy E) : SmallVectorImpl<T>(NumTsAvailable) {
     this->append(S, E);
   }
-  
+
   SmallVector(const SmallVector &RHS) : SmallVectorImpl<T>(NumTsAvailable) {
     if (!RHS.empty())
       SmallVectorImpl<T>::operator=(RHS);
@@ -583,7 +583,7 @@ public:
     SmallVectorImpl<T>::operator=(RHS);
     return *this;
   }
-  
+
 };
 
 } // End llvm namespace
@@ -595,7 +595,7 @@ namespace std {
   swap(llvm::SmallVectorImpl<T> &LHS, llvm::SmallVectorImpl<T> &RHS) {
     LHS.swap(RHS);
   }
-  
+
   /// Implement std::swap in terms of SmallVector swap.
   template<typename T, unsigned N>
   inline void