1 files changed, 26 insertions, 26 deletions

diff --git a/include/clang/Analysis/PathSensitive/Store.h b/include/clang/Analysis/PathSensitive/Store.h
index 51143ec84b..047bc6c680 100644
--- a/include/clang/Analysis/PathSensitive/Store.h
+++ b/include/clang/Analysis/PathSensitive/Store.h
@@ -23,16 +23,16 @@
 #include "llvm/ADT/SmallVector.h"
 
 namespace clang {
-  
+
 typedef const void* Store;
 
-class GRState;  
+class GRState;
 class GRStateManager;
 class Stmt;
 class Expr;
 class ObjCIvarDecl;
 class SubRegionMap;
-  
+
 class StoreManager {
 protected:
   ValueManager &ValMgr;
@@ -43,13 +43,13 @@ protected:
 
   StoreManager(GRStateManager &stateMgr);
 
-public:  
+public:
   virtual ~StoreManager() {}
-  
+
   /// Return the value bound to specified location in a given state.
   /// \param[in] state The analysis state.
   /// \param[in] loc The symbolic memory location.
-  /// \param[in] T An optional type that provides a hint indicating the 
+  /// \param[in] T An optional type that provides a hint indicating the
   ///   expected type of the returned value.  This is used if the value is
   ///   lazily computed.
   /// \return The value bound to the location \c loc.
@@ -60,13 +60,13 @@ public:
   /// \param[in] state The analysis state.
   /// \param[in] loc The symbolic memory location.
   /// \param[in] val The value to bind to location \c loc.
-  /// \return A pointer to a GRState object that contains the same bindings as 
+  /// \return A pointer to a GRState object that contains the same bindings as
   ///   \c state with the addition of having the value specified by \c val bound
   ///   to the location given for \c loc.
   virtual const GRState *Bind(const GRState *state, Loc loc, SVal val) = 0;
 
   virtual Store Remove(Store St, Loc L) = 0;
-  
+
   /// BindCompoundLiteral - Return the store that has the bindings currently
   ///  in 'store' plus the bindings for the CompoundLiteral.  'R' is the region
   ///  for the compound literal and 'BegInit' and 'EndInit' represent an
@@ -74,15 +74,15 @@ public:
   virtual const GRState *BindCompoundLiteral(const GRState *state,
                                               const CompoundLiteralExpr* cl,
                                               SVal v) = 0;
-  
+
   /// getInitialStore - Returns the initial "empty" store representing the
   ///  value bindings upon entry to an analyzed function.
   virtual Store getInitialStore(const LocationContext *InitLoc) = 0;
-  
+
   /// getRegionManager - Returns the internal RegionManager object that is
   ///  used to query and manipulate MemRegion objects.
   MemRegionManager& getRegionManager() { return MRMgr; }
-  
+
   /// getSubRegionMap - Returns an opaque map object that clients can query
   ///  to get the subregions of a given MemRegion object.  It is the
   //   caller's responsibility to 'delete' the returned map.
@@ -96,13 +96,13 @@ public:
 
   virtual SVal getLValueCompoundLiteral(const GRState *state,
                                         const CompoundLiteralExpr* cl) = 0;
-  
+
   virtual SVal getLValueIvar(const GRState *state, const ObjCIvarDecl* decl,
                              SVal base) = 0;
-  
+
   virtual SVal getLValueField(const GRState *state, SVal base,
                               const FieldDecl* D) = 0;
-  
+
   virtual SVal getLValueElement(const GRState *state, QualType elementType,
                                 SVal base, SVal offset) = 0;
 
@@ -114,7 +114,7 @@ public:
   /// ArrayToPointer - Used by GRExprEngine::VistCast to handle implicit
   ///  conversions between arrays and pointers.
   virtual SVal ArrayToPointer(Loc Array) = 0;
-  
+
   class CastResult {
     const GRState *state;
     const MemRegion *region;
@@ -123,19 +123,19 @@ public:
     const MemRegion* getRegion() const { return region; }
     CastResult(const GRState *s, const MemRegion* r = 0) : state(s), region(r){}
   };
-  
+
   /// CastRegion - Used by GRExprEngine::VisitCast to handle casts from
   ///  a MemRegion* to a specific location type.  'R' is the region being
   ///  casted and 'CastToTy' the result type of the cast.
   CastResult CastRegion(const GRState *state, const MemRegion *region,
-                        QualType CastToTy);  
+                        QualType CastToTy);
 
   /// EvalBinOp - Perform pointer arithmetic.
   virtual SVal EvalBinOp(const GRState *state, BinaryOperator::Opcode Op,
                          Loc lhs, NonLoc rhs, QualType resultTy) {
     return UnknownVal();
   }
-  
+
   virtual void RemoveDeadBindings(GRState &state, Stmt* Loc,
                                   SymbolReaper& SymReaper,
                       llvm::SmallVectorImpl<const MemRegion*>& RegionRoots) = 0;
@@ -166,14 +166,14 @@ public:
 
   virtual void print(Store store, llvm::raw_ostream& Out,
                      const char* nl, const char *sep) = 0;
-      
+
   class BindingsHandler {
-  public:    
+  public:
     virtual ~BindingsHandler();
     virtual bool HandleBinding(StoreManager& SMgr, Store store,
                                const MemRegion *region, SVal val) = 0;
   };
-  
+
   /// iterBindings - Iterate over the bindings in the Store.
   virtual void iterBindings(Store store, BindingsHandler& f) = 0;
 
@@ -181,12 +181,12 @@ protected:
   CastResult MakeElementRegion(const GRState *state, const MemRegion *region,
                                QualType pointeeTy, QualType castToTy,
                                uint64_t index = 0);
-  
+
   /// CastRetrievedVal - Used by subclasses of StoreManager to implement
   ///  implicit casts that arise from loads from regions that are reinterpreted
   ///  as another region.
   SValuator::CastResult CastRetrievedVal(SVal val, const GRState *state,
-                                         const TypedRegion *R, QualType castTy);    
+                                         const TypedRegion *R, QualType castTy);
 };
 
 // FIXME: Do we still need this?
@@ -195,14 +195,14 @@ protected:
 class SubRegionMap {
 public:
   virtual ~SubRegionMap() {}
-  
+
   class Visitor {
   public:
     virtual ~Visitor() {};
     virtual bool Visit(const MemRegion* Parent, const MemRegion* SubRegion) = 0;
   };
-  
-  virtual bool iterSubRegions(const MemRegion *region, Visitor& V) const = 0;  
+
+  virtual bool iterSubRegions(const MemRegion *region, Visitor& V) const = 0;
 };
 
 // FIXME: Do we need to pass GRStateManager anymore?