1 files changed, 63 insertions, 63 deletions

diff --git a/include/clang/Analysis/Support/BlkExprDeclBitVector.h b/include/clang/Analysis/Support/BlkExprDeclBitVector.h
index 7944c8e682..27ecc66e66 100644
--- a/include/clang/Analysis/Support/BlkExprDeclBitVector.h
+++ b/include/clang/Analysis/Support/BlkExprDeclBitVector.h
@@ -23,18 +23,18 @@
 #include "llvm/ADT/DenseMap.h"
 
 namespace clang {
-  
+
   class Stmt;
   class ASTContext;
 
 struct DeclBitVector_Types {
-  
+
   class Idx {
     unsigned I;
   public:
     explicit Idx(unsigned i) : I(i) {}
     Idx() : I(~0U) {}
-    
+
     bool isValid() const {
       return I != ~0U;
     }
@@ -42,35 +42,35 @@ struct DeclBitVector_Types {
       assert (isValid());
       return I;
     }
-  };    
-    
+  };
+
   //===--------------------------------------------------------------------===//
   // AnalysisDataTy - Whole-function meta data.
   //===--------------------------------------------------------------------===//
-  
+
   class AnalysisDataTy {
   public:
     typedef llvm::DenseMap<const NamedDecl*, unsigned > DMapTy;
     typedef DMapTy::const_iterator decl_iterator;
-    
+
   protected:
-    DMapTy DMap;    
+    DMapTy DMap;
     unsigned NDecls;
-    
+
   public:
-    
+
     AnalysisDataTy() : NDecls(0) {}
     virtual ~AnalysisDataTy() {}
-    
+
     bool isTracked(const NamedDecl* SD) { return DMap.find(SD) != DMap.end(); }
-    
+
     Idx getIdx(const NamedDecl* SD) const {
       DMapTy::const_iterator I = DMap.find(SD);
       return I == DMap.end() ? Idx() : Idx(I->second);
     }
 
     unsigned getNumDecls() const { return NDecls; }
-    
+
     void Register(const NamedDecl* SD) {
       if (!isTracked(SD)) DMap[SD] = NDecls++;
     }
@@ -78,44 +78,44 @@ struct DeclBitVector_Types {
     decl_iterator begin_decl() const { return DMap.begin(); }
     decl_iterator end_decl() const { return DMap.end(); }
   };
-  
+
   //===--------------------------------------------------------------------===//
   // ValTy - Dataflow value.
   //===--------------------------------------------------------------------===//
-  
+
   class ValTy {
     llvm::BitVector DeclBV;
   public:
-    
+
     void resetDeclValues(AnalysisDataTy& AD) {
-      DeclBV.resize(AD.getNumDecls()); 
+      DeclBV.resize(AD.getNumDecls());
       DeclBV.reset();
     }
 
     void setDeclValues(AnalysisDataTy& AD) {
-      DeclBV.resize(AD.getNumDecls()); 
+      DeclBV.resize(AD.getNumDecls());
       DeclBV.set();
     }
-    
+
     void resetValues(AnalysisDataTy& AD) {
       resetDeclValues(AD);
-    }    
-    
-    bool operator==(const ValTy& RHS) const { 
+    }
+
+    bool operator==(const ValTy& RHS) const {
       assert (sizesEqual(RHS));
       return DeclBV == RHS.DeclBV;
     }
-    
+
     void copyValues(const ValTy& RHS) { DeclBV = RHS.DeclBV; }
-    
+
     llvm::BitVector::reference getBit(unsigned i) {
       return DeclBV[i];
     }
-    
+
     bool getBit(unsigned i) const {
       return DeclBV[i];
     }
-    
+
     llvm::BitVector::reference
     operator()(const NamedDecl* ND, const AnalysisDataTy& AD) {
       return getBit(AD.getIdx(ND));
@@ -124,48 +124,48 @@ struct DeclBitVector_Types {
     bool operator()(const NamedDecl* ND, const AnalysisDataTy& AD) const {
       return getBit(AD.getIdx(ND));
     }
-    
-    llvm::BitVector::reference getDeclBit(unsigned i) { return DeclBV[i]; }    
+
+    llvm::BitVector::reference getDeclBit(unsigned i) { return DeclBV[i]; }
     const llvm::BitVector::reference getDeclBit(unsigned i) const {
       return const_cast<llvm::BitVector&>(DeclBV)[i];
     }
-        
+
     ValTy& operator|=(const ValTy& RHS) {
       assert (sizesEqual(RHS));
       DeclBV |= RHS.DeclBV;
       return *this;
     }
-    
+
     ValTy& operator&=(const ValTy& RHS) {
       assert (sizesEqual(RHS));
       DeclBV &= RHS.DeclBV;
       return *this;
     }
-    
+
     ValTy& OrDeclBits(const ValTy& RHS) {
       return operator|=(RHS);
     }
-    
+
     ValTy& AndDeclBits(const ValTy& RHS) {
       return operator&=(RHS);
     }
-        
+
     bool sizesEqual(const ValTy& RHS) const {
       return DeclBV.size() == RHS.DeclBV.size();
     }
   };
-  
+
   //===--------------------------------------------------------------------===//
   // Some useful merge operations.
   //===--------------------------------------------------------------------===//
-    
+
   struct Union { void operator()(ValTy& Dst, ValTy& Src) { Dst |= Src; } };
   struct Intersect { void operator()(ValTy& Dst, ValTy& Src) { Dst &= Src; } };
 };
 
 
 struct StmtDeclBitVector_Types {
-  
+
   //===--------------------------------------------------------------------===//
   // AnalysisDataTy - Whole-function meta data.
   //===--------------------------------------------------------------------===//
@@ -179,13 +179,13 @@ struct StmtDeclBitVector_Types {
 
     void setContext(ASTContext& c) { ctx = &c; }
     ASTContext& getContext() {
-      assert(ctx && "ASTContext should not be NULL."); 
+      assert(ctx && "ASTContext should not be NULL.");
       return *ctx;
     }
 
     void setCFG(CFG& c) { cfg = &c; }
     CFG& getCFG() { assert(cfg && "CFG should not be NULL."); return *cfg; }
-    
+
     bool isTracked(const Stmt* S) { return cfg->isBlkExpr(S); }
     using DeclBitVector_Types::AnalysisDataTy::isTracked;
 
@@ -195,7 +195,7 @@ struct StmtDeclBitVector_Types {
       return I;
     }
     using DeclBitVector_Types::AnalysisDataTy::getIdx;
-    
+
     unsigned getNumBlkExprs() const { return cfg->getNumBlkExprs(); }
   };
 
@@ -206,101 +206,101 @@ struct StmtDeclBitVector_Types {
   class ValTy : public DeclBitVector_Types::ValTy {
     llvm::BitVector BlkExprBV;
     typedef DeclBitVector_Types::ValTy ParentTy;
-    
+
     static inline ParentTy& ParentRef(ValTy& X) {
       return static_cast<ParentTy&>(X);
     }
-    
+
     static inline const ParentTy& ParentRef(const ValTy& X) {
       return static_cast<const ParentTy&>(X);
     }
-    
+
   public:
 
     void resetBlkExprValues(AnalysisDataTy& AD) {
       BlkExprBV.resize(AD.getNumBlkExprs());
       BlkExprBV.reset();
     }
-    
+
     void setBlkExprValues(AnalysisDataTy& AD) {
       BlkExprBV.resize(AD.getNumBlkExprs());
       BlkExprBV.set();
     }
-    
+
     void resetValues(AnalysisDataTy& AD) {
       resetDeclValues(AD);
       resetBlkExprValues(AD);
     }
-    
+
     void setValues(AnalysisDataTy& AD) {
       setDeclValues(AD);
       setBlkExprValues(AD);
     }
-    
-    bool operator==(const ValTy& RHS) const { 
-      return ParentRef(*this) == ParentRef(RHS) 
+
+    bool operator==(const ValTy& RHS) const {
+      return ParentRef(*this) == ParentRef(RHS)
           && BlkExprBV == RHS.BlkExprBV;
     }
-    
+
     void copyValues(const ValTy& RHS) {
       ParentRef(*this).copyValues(ParentRef(RHS));
       BlkExprBV = RHS.BlkExprBV;
     }
-        
+
     llvm::BitVector::reference
     operator()(const Stmt* S, const AnalysisDataTy& AD) {
-      return BlkExprBV[AD.getIdx(S)];      
-    }    
+      return BlkExprBV[AD.getIdx(S)];
+    }
     const llvm::BitVector::reference
     operator()(const Stmt* S, const AnalysisDataTy& AD) const {
       return const_cast<ValTy&>(*this)(S,AD);
     }
-    
+
     using DeclBitVector_Types::ValTy::operator();
 
-    
-    llvm::BitVector::reference getStmtBit(unsigned i) { return BlkExprBV[i]; }    
+
+    llvm::BitVector::reference getStmtBit(unsigned i) { return BlkExprBV[i]; }
     const llvm::BitVector::reference getStmtBit(unsigned i) const {
       return const_cast<llvm::BitVector&>(BlkExprBV)[i];
     }
-    
+
     ValTy& OrBlkExprBits(const ValTy& RHS) {
       BlkExprBV |= RHS.BlkExprBV;
       return *this;
     }
-    
+
     ValTy& AndBlkExprBits(const ValTy& RHS) {
       BlkExprBV &= RHS.BlkExprBV;
       return *this;
     }
-    
+
     ValTy& operator|=(const ValTy& RHS) {
       assert (sizesEqual(RHS));
       ParentRef(*this) |= ParentRef(RHS);
       BlkExprBV |= RHS.BlkExprBV;
       return *this;
     }
-    
+
     ValTy& operator&=(const ValTy& RHS) {
       assert (sizesEqual(RHS));
       ParentRef(*this) &= ParentRef(RHS);
       BlkExprBV &= RHS.BlkExprBV;
       return *this;
     }
-    
+
     bool sizesEqual(const ValTy& RHS) const {
       return ParentRef(*this).sizesEqual(ParentRef(RHS))
           && BlkExprBV.size() == RHS.BlkExprBV.size();
     }
   };
-  
+
   //===--------------------------------------------------------------------===//
   // Some useful merge operations.
   //===--------------------------------------------------------------------===//
-  
+
   struct Union { void operator()(ValTy& Dst, ValTy& Src) { Dst |= Src; } };
   struct Intersect { void operator()(ValTy& Dst, ValTy& Src) { Dst &= Src; } };
-  
+
 };
 } // end namespace clang