1 files changed, 71 insertions, 71 deletions

diff --git a/include/clang/Analysis/PathSensitive/ExplodedGraph.h b/include/clang/Analysis/PathSensitive/ExplodedGraph.h
index 4ffed8950a..fc41333f27 100644
--- a/include/clang/Analysis/PathSensitive/ExplodedGraph.h
+++ b/include/clang/Analysis/PathSensitive/ExplodedGraph.h
@@ -38,7 +38,7 @@ class ASTContext;
 // contain a specific kind of state.  Typed-specialized versions are defined
 // on top of these classes.
 //===----------------------------------------------------------------------===//
-  
+
 class ExplodedNode : public llvm::FoldingSetNode {
   friend class ExplodedGraph;
   friend class GRCoreEngine;
@@ -46,16 +46,16 @@ class ExplodedNode : public llvm::FoldingSetNode {
   friend class GRBranchNodeBuilder;
   friend class GRIndirectGotoNodeBuilder;
   friend class GRSwitchNodeBuilder;
-  friend class GREndPathNodeBuilder;  
-  
+  friend class GREndPathNodeBuilder;
+
   class NodeGroup {
     enum { Size1 = 0x0, SizeOther = 0x1, AuxFlag = 0x2, Mask = 0x3 };
     uintptr_t P;
-    
+
     unsigned getKind() const {
       return P & 0x1;
     }
-    
+
     void* getPtr() const {
       assert (!getFlag());
       return reinterpret_cast<void*>(P & ~Mask);
@@ -64,55 +64,55 @@ class ExplodedNode : public llvm::FoldingSetNode {
     ExplodedNode *getNode() const {
       return reinterpret_cast<ExplodedNode*>(getPtr());
     }
-    
+
   public:
     NodeGroup() : P(0) {}
-    
+
     ~NodeGroup();
-    
+
     ExplodedNode** begin() const;
-    
+
     ExplodedNode** end() const;
-    
+
     unsigned size() const;
-    
+
     bool empty() const { return size() == 0; }
-    
+
     void addNode(ExplodedNode* N);
-    
+
     void setFlag() {
       assert (P == 0);
       P = AuxFlag;
     }
-    
+
     bool getFlag() const {
       return P & AuxFlag ? true : false;
     }
-  };  
-  
+  };
+
   /// Location - The program location (within a function body) associated
   ///  with this node.
   const ProgramPoint Location;
-  
+
   /// State - The state associated with this node.
   const GRState* State;
-  
+
   /// Preds - The predecessors of this node.
   NodeGroup Preds;
-  
+
   /// Succs - The successors of this node.
   NodeGroup Succs;
 
 public:
 
-  explicit ExplodedNode(const ProgramPoint& loc, const GRState* state) 
+  explicit ExplodedNode(const ProgramPoint& loc, const GRState* state)
     : Location(loc), State(state) {}
 
   /// getLocation - Returns the edge associated with the given node.
   ProgramPoint getLocation() const { return Location; }
 
-  const LocationContext *getLocationContext() const { 
-    return getLocation().getLocationContext(); 
+  const LocationContext *getLocationContext() const {
+    return getLocation().getLocationContext();
   }
 
   const Decl &getCodeDecl() const { return *getLocationContext()->getDecl(); }
@@ -126,14 +126,14 @@ public:
   template <typename T>
   const T* getLocationAs() const { return llvm::dyn_cast<T>(&Location); }
 
-  static void Profile(llvm::FoldingSetNodeID &ID, 
+  static void Profile(llvm::FoldingSetNodeID &ID,
                       const ProgramPoint& Loc, const GRState* state);
 
   void Profile(llvm::FoldingSetNodeID& ID) const {
     Profile(ID, getLocation(), getState());
   }
 
-  /// addPredeccessor - Adds a predecessor to the current node, and 
+  /// addPredeccessor - Adds a predecessor to the current node, and
   ///  in tandem add this node as a successor of the other node.
   void addPredecessor(ExplodedNode* V);
 
@@ -141,18 +141,18 @@ public:
   unsigned pred_size() const { return Preds.size(); }
   bool succ_empty() const { return Succs.empty(); }
   bool pred_empty() const { return Preds.empty(); }
-  
+
   bool isSink() const { return Succs.getFlag(); }
-  void markAsSink() { Succs.setFlag(); } 
+  void markAsSink() { Succs.setFlag(); }
 
   ExplodedNode* getFirstPred() {
     return pred_empty() ? NULL : *(pred_begin());
   }
-  
+
   const ExplodedNode* getFirstPred() const {
     return const_cast<ExplodedNode*>(this)->getFirstPred();
   }
-  
+
   // Iterators over successor and predecessor vertices.
   typedef ExplodedNode**       succ_iterator;
   typedef const ExplodedNode* const * const_succ_iterator;
@@ -164,7 +164,7 @@ public:
 
   const_pred_iterator pred_begin() const {
     return const_cast<ExplodedNode*>(this)->pred_begin();
-  }  
+  }
   const_pred_iterator pred_end() const {
     return const_cast<ExplodedNode*>(this)->pred_end();
   }
@@ -180,26 +180,26 @@ public:
   }
 
   // For debugging.
-  
+
 public:
-  
+
   class Auditor {
   public:
     virtual ~Auditor();
     virtual void AddEdge(ExplodedNode* Src, ExplodedNode* Dst) = 0;
   };
-  
+
   static void SetAuditor(Auditor* A);
 };
 
 // FIXME: Is this class necessary?
 class InterExplodedGraphMap {
   llvm::DenseMap<const ExplodedNode*, ExplodedNode*> M;
-  friend class ExplodedGraph;  
+  friend class ExplodedGraph;
 
 public:
   ExplodedNode* getMappedNode(const ExplodedNode* N) const;
-  
+
   InterExplodedGraphMap() {};
   virtual ~InterExplodedGraphMap() {}
 };
@@ -211,7 +211,7 @@ protected:
   // Type definitions.
   typedef llvm::SmallVector<ExplodedNode*,2>    RootsTy;
   typedef llvm::SmallVector<ExplodedNode*,10>   EndNodesTy;
-    
+
   /// Roots - The roots of the simulation graph. Usually there will be only
   /// one, but clients are free to establish multiple subgraphs within a single
   /// SimulGraph. Moreover, these subgraphs can often merge when paths from
@@ -227,10 +227,10 @@ protected:
 
   /// Allocator - BumpPtrAllocator to create nodes.
   llvm::BumpPtrAllocator Allocator;
-  
+
   /// Ctx - The ASTContext used to "interpret" CodeDecl.
   ASTContext& Ctx;
-  
+
   /// NumNodes - The number of nodes in the graph.
   unsigned NumNodes;
 
@@ -242,7 +242,7 @@ public:
 
   ExplodedNode* getNode(const ProgramPoint& L, const GRState *State,
                         bool* IsNew = 0);
-  
+
   ExplodedGraph* MakeEmptyGraph() const {
     return new ExplodedGraph(Ctx);
   }
@@ -265,7 +265,7 @@ public:
 
   unsigned num_roots() const { return Roots.size(); }
   unsigned num_eops() const { return EndNodes.size(); }
-  
+
   bool empty() const { return NumNodes == 0; }
   unsigned size() const { return NumNodes; }
 
@@ -278,29 +278,29 @@ public:
   typedef NodeTy* const *                     const_eop_iterator;
   typedef AllNodesTy::iterator                node_iterator;
   typedef AllNodesTy::const_iterator          const_node_iterator;
-  
+
   node_iterator nodes_begin() { return Nodes.begin(); }
 
   node_iterator nodes_end() { return Nodes.end(); }
-  
+
   const_node_iterator nodes_begin() const { return Nodes.begin(); }
-  
+
   const_node_iterator nodes_end() const { return Nodes.end(); }
-  
+
   roots_iterator roots_begin() { return Roots.begin(); }
-  
+
   roots_iterator roots_end() { return Roots.end(); }
-  
+
   const_roots_iterator roots_begin() const { return Roots.begin(); }
-  
-  const_roots_iterator roots_end() const { return Roots.end(); }  
+
+  const_roots_iterator roots_end() const { return Roots.end(); }
 
   eop_iterator eop_begin() { return EndNodes.begin(); }
-    
+
   eop_iterator eop_end() { return EndNodes.end(); }
-  
+
   const_eop_iterator eop_begin() const { return EndNodes.begin(); }
-  
+
   const_eop_iterator eop_end() const { return EndNodes.end(); }
 
   llvm::BumpPtrAllocator& getAllocator() { return Allocator; }
@@ -322,24 +322,24 @@ public:
 class ExplodedNodeSet {
   typedef llvm::SmallPtrSet<ExplodedNode*,5> ImplTy;
   ImplTy Impl;
-  
+
 public:
   ExplodedNodeSet(ExplodedNode* N) {
     assert (N && !static_cast<ExplodedNode*>(N)->isSink());
     Impl.insert(N);
   }
-  
+
   ExplodedNodeSet() {}
-  
+
   inline void Add(ExplodedNode* N) {
     if (N && !static_cast<ExplodedNode*>(N)->isSink()) Impl.insert(N);
   }
-  
+
   ExplodedNodeSet& operator=(const ExplodedNodeSet &X) {
     Impl = X.Impl;
     return *this;
   }
-  
+
   typedef ImplTy::iterator       iterator;
   typedef ImplTy::const_iterator const_iterator;
 
@@ -347,14 +347,14 @@ public:
   inline bool empty()    const { return Impl.empty(); }
 
   inline void clear() { Impl.clear(); }
-  
+
   inline iterator begin() { return Impl.begin(); }
   inline iterator end()   { return Impl.end();   }
-  
+
   inline const_iterator begin() const { return Impl.begin(); }
   inline const_iterator end()   const { return Impl.end();   }
-};  
-  
+};
+
 } // end clang namespace
 
 // GraphTraits
@@ -364,54 +364,54 @@ namespace llvm {
     typedef clang::ExplodedNode NodeType;
     typedef NodeType::succ_iterator  ChildIteratorType;
     typedef llvm::df_iterator<NodeType*>      nodes_iterator;
-    
+
     static inline NodeType* getEntryNode(NodeType* N) {
       return N;
     }
-    
+
     static inline ChildIteratorType child_begin(NodeType* N) {
       return N->succ_begin();
     }
-    
+
     static inline ChildIteratorType child_end(NodeType* N) {
       return N->succ_end();
     }
-    
+
     static inline nodes_iterator nodes_begin(NodeType* N) {
       return df_begin(N);
     }
-    
+
     static inline nodes_iterator nodes_end(NodeType* N) {
       return df_end(N);
     }
   };
-  
+
   template<> struct GraphTraits<const clang::ExplodedNode*> {
     typedef const clang::ExplodedNode NodeType;
     typedef NodeType::const_succ_iterator   ChildIteratorType;
     typedef llvm::df_iterator<NodeType*>       nodes_iterator;
-    
+
     static inline NodeType* getEntryNode(NodeType* N) {
       return N;
     }
-    
+
     static inline ChildIteratorType child_begin(NodeType* N) {
       return N->succ_begin();
     }
-    
+
     static inline ChildIteratorType child_end(NodeType* N) {
       return N->succ_end();
     }
-    
+
     static inline nodes_iterator nodes_begin(NodeType* N) {
       return df_begin(N);
     }
-    
+
     static inline nodes_iterator nodes_end(NodeType* N) {
       return df_end(N);
     }
   };
-  
+
 } // end llvm namespace
 
 #endif