Rename all 'EvalXXX' methods in libChecker to

'evalXXX'.

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

23 files changed, 283 insertions, 283 deletions

diff --git a/lib/Checker/AdjustedReturnValueChecker.cpp b/lib/Checker/AdjustedReturnValueChecker.cpp
index 5f56401413..2d2206a269 100644
--- a/lib/Checker/AdjustedReturnValueChecker.cpp
+++ b/lib/Checker/AdjustedReturnValueChecker.cpp
@@ -89,7 +89,7 @@ void AdjustedReturnValueChecker::PostVisitCallExpr(CheckerContext &C,
     // FIXME: Do more checking and actual emit an error. At least performing
     // the cast avoids some assertion failures elsewhere.
     SValBuilder &svalBuilder = C.getSValBuilder();
-    V = svalBuilder.EvalCast(V, expectedResultTy, actualResultTy);
+    V = svalBuilder.evalCast(V, expectedResultTy, actualResultTy);
     C.GenerateNode(state->BindExpr(CE, V));
   }
 }
diff --git a/lib/Checker/BasicObjCFoundationChecks.cpp b/lib/Checker/BasicObjCFoundationChecks.cpp
index c137e7d6f7..5db957fcfb 100644
--- a/lib/Checker/BasicObjCFoundationChecks.cpp
+++ b/lib/Checker/BasicObjCFoundationChecks.cpp
@@ -414,7 +414,7 @@ void CFRetainReleaseChecker::PreVisitCallExpr(CheckerContext& C,
 
   // Make an expression asserting that they're equal.
   SValBuilder &svalBuilder = ValMgr.getSValBuilder();
-  DefinedOrUnknownSVal ArgIsNull = svalBuilder.EvalEQ(state, Zero, *DefArgVal);
+  DefinedOrUnknownSVal ArgIsNull = svalBuilder.evalEQ(state, Zero, *DefArgVal);
 
   // Are they equal?
   const GRState *stateTrue, *stateFalse;
diff --git a/lib/Checker/BasicValueFactory.cpp b/lib/Checker/BasicValueFactory.cpp
index 4c9b109c88..c6b71a9b0d 100644
--- a/lib/Checker/BasicValueFactory.cpp
+++ b/lib/Checker/BasicValueFactory.cpp
@@ -142,7 +142,7 @@ BasicValueFactory::getLazyCompoundValData(const void *store,
 }
 
 const llvm::APSInt*
-BasicValueFactory::EvaluateAPSInt(BinaryOperator::Opcode Op,
+BasicValueFactory::evalAPSInt(BinaryOperator::Opcode Op,
                              const llvm::APSInt& V1, const llvm::APSInt& V2) {
 
   switch (Op) {
diff --git a/lib/Checker/BuiltinFunctionChecker.cpp b/lib/Checker/BuiltinFunctionChecker.cpp
index 6761a7a567..a43a28449b 100644
--- a/lib/Checker/BuiltinFunctionChecker.cpp
+++ b/lib/Checker/BuiltinFunctionChecker.cpp
@@ -22,7 +22,7 @@ namespace {
 class BuiltinFunctionChecker : public Checker {
 public:
   static void *getTag() { static int tag = 0; return &tag; }
-  virtual bool EvalCallExpr(CheckerContext &C, const CallExpr *CE);
+  virtual bool evalCallExpr(CheckerContext &C, const CallExpr *CE);
 };
 
 }
@@ -31,7 +31,7 @@ void clang::RegisterBuiltinFunctionChecker(GRExprEngine &Eng) {
   Eng.registerCheck(new BuiltinFunctionChecker());
 }
 
-bool BuiltinFunctionChecker::EvalCallExpr(CheckerContext &C,const CallExpr *CE){
+bool BuiltinFunctionChecker::evalCallExpr(CheckerContext &C,const CallExpr *CE){
   const GRState *state = C.getState();
   const Expr *Callee = CE->getCallee();
   SVal L = state->getSVal(Callee);
@@ -72,7 +72,7 @@ bool BuiltinFunctionChecker::EvalCallExpr(CheckerContext &C,const CallExpr *CE){
 
     SValBuilder& svalBuilder = ValMgr.getSValBuilder();
     DefinedOrUnknownSVal ExtentMatchesSizeArg =
-      svalBuilder.EvalEQ(state, Extent, Size);
+      svalBuilder.evalEQ(state, Extent, Size);
     state = state->Assume(ExtentMatchesSizeArg, true);
 
     C.GenerateNode(state->BindExpr(CE, loc::MemRegionVal(R)));
diff --git a/lib/Checker/CFRefCount.cpp b/lib/Checker/CFRefCount.cpp
index 80cbfc50ad..a1eff948c7 100644
--- a/lib/Checker/CFRefCount.cpp
+++ b/lib/Checker/CFRefCount.cpp
@@ -1710,7 +1710,7 @@ public:
 
   // Calls.
 
-  void EvalSummary(ExplodedNodeSet& Dst,
+  void evalSummary(ExplodedNodeSet& Dst,
                    GRExprEngine& Eng,
                    GRStmtNodeBuilder& Builder,
                    const Expr* Ex,
@@ -1720,28 +1720,28 @@ public:
                    ConstExprIterator arg_beg, ConstExprIterator arg_end,
                    ExplodedNode* Pred, const GRState *state);
 
-  virtual void EvalCall(ExplodedNodeSet& Dst,
+  virtual void evalCall(ExplodedNodeSet& Dst,
                         GRExprEngine& Eng,
                         GRStmtNodeBuilder& Builder,
                         const CallExpr* CE, SVal L,
                         ExplodedNode* Pred);
 
 
-  virtual void EvalObjCMessageExpr(ExplodedNodeSet& Dst,
+  virtual void evalObjCMessageExpr(ExplodedNodeSet& Dst,
                                    GRExprEngine& Engine,
                                    GRStmtNodeBuilder& Builder,
                                    const ObjCMessageExpr* ME,
                                    ExplodedNode* Pred,
                                    const GRState *state);
   // Stores.
-  virtual void EvalBind(GRStmtNodeBuilderRef& B, SVal location, SVal val);
+  virtual void evalBind(GRStmtNodeBuilderRef& B, SVal location, SVal val);
 
   // End-of-path.
 
-  virtual void EvalEndPath(GRExprEngine& Engine,
+  virtual void evalEndPath(GRExprEngine& Engine,
                            GREndPathNodeBuilder& Builder);
 
-  virtual void EvalDeadSymbols(ExplodedNodeSet& Dst,
+  virtual void evalDeadSymbols(ExplodedNodeSet& Dst,
                                GRExprEngine& Engine,
                                GRStmtNodeBuilder& Builder,
                                ExplodedNode* Pred,
@@ -1754,7 +1754,7 @@ public:
                           SymbolRef Sym, RefVal V, bool &stop);
   // Return statements.
 
-  virtual void EvalReturn(ExplodedNodeSet& Dst,
+  virtual void evalReturn(ExplodedNodeSet& Dst,
                           GRExprEngine& Engine,
                           GRStmtNodeBuilder& Builder,
                           const ReturnStmt* S,
@@ -1762,7 +1762,7 @@ public:
 
   // Assumptions.
 
-  virtual const GRState *EvalAssume(const GRState* state, SVal condition,
+  virtual const GRState *evalAssume(const GRState* state, SVal condition,
                                     bool assumption);
 };
 
@@ -2494,7 +2494,7 @@ static QualType GetReturnType(const Expr* RetE, ASTContext& Ctx) {
   return RetTy;
 }
 
-void CFRefCount::EvalSummary(ExplodedNodeSet& Dst,
+void CFRefCount::evalSummary(ExplodedNodeSet& Dst,
                              GRExprEngine& Eng,
                              GRStmtNodeBuilder& Builder,
                              const Expr* Ex,
@@ -2756,7 +2756,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet& Dst,
 }
 
 
-void CFRefCount::EvalCall(ExplodedNodeSet& Dst,
+void CFRefCount::evalCall(ExplodedNodeSet& Dst,
                           GRExprEngine& Eng,
                           GRStmtNodeBuilder& Builder,
                           const CallExpr* CE, SVal L,
@@ -2777,11 +2777,11 @@ void CFRefCount::EvalCall(ExplodedNodeSet& Dst,
   }
 
   assert(Summ);
-  EvalSummary(Dst, Eng, Builder, CE, 0, *Summ, L.getAsRegion(),
+  evalSummary(Dst, Eng, Builder, CE, 0, *Summ, L.getAsRegion(),
               CE->arg_begin(), CE->arg_end(), Pred, Builder.GetState(Pred));
 }
 
-void CFRefCount::EvalObjCMessageExpr(ExplodedNodeSet& Dst,
+void CFRefCount::evalObjCMessageExpr(ExplodedNodeSet& Dst,
                                      GRExprEngine& Eng,
                                      GRStmtNodeBuilder& Builder,
                                      const ObjCMessageExpr* ME,
@@ -2793,7 +2793,7 @@ void CFRefCount::EvalObjCMessageExpr(ExplodedNodeSet& Dst,
       : Summaries.getClassMethodSummary(ME);
 
   assert(Summ && "RetainSummary is null");
-  EvalSummary(Dst, Eng, Builder, ME,
+  evalSummary(Dst, Eng, Builder, ME,
               InstanceReceiver(ME, Pred->getLocationContext()), *Summ, NULL,
               ME->arg_begin(), ME->arg_end(), Pred, state);
 }
@@ -2813,7 +2813,7 @@ public:
 } // end anonymous namespace
 
 
-void CFRefCount::EvalBind(GRStmtNodeBuilderRef& B, SVal location, SVal val) {
+void CFRefCount::evalBind(GRStmtNodeBuilderRef& B, SVal location, SVal val) {
   // Are we storing to something that causes the value to "escape"?
   bool escapes = false;
 
@@ -2852,7 +2852,7 @@ void CFRefCount::EvalBind(GRStmtNodeBuilderRef& B, SVal location, SVal val) {
 
  // Return statements.
 
-void CFRefCount::EvalReturn(ExplodedNodeSet& Dst,
+void CFRefCount::evalReturn(ExplodedNodeSet& Dst,
                             GRExprEngine& Eng,
                             GRStmtNodeBuilder& Builder,
                             const ReturnStmt* S,
@@ -2994,14 +2994,14 @@ void CFRefCount::EvalReturn(ExplodedNodeSet& Dst,
 
 // Assumptions.
 
-const GRState* CFRefCount::EvalAssume(const GRState *state,
+const GRState* CFRefCount::evalAssume(const GRState *state,
                                       SVal Cond, bool Assumption) {
 
-  // FIXME: We may add to the interface of EvalAssume the list of symbols
+  // FIXME: We may add to the interface of evalAssume the list of symbols
   //  whose assumptions have changed.  For now we just iterate through the
   //  bindings and check if any of the tracked symbols are NULL.  This isn't
   //  too bad since the number of symbols we will track in practice are
-  //  probably small and EvalAssume is only called at branches and a few
+  //  probably small and evalAssume is only called at branches and a few
   //  other places.
   RefBindings B = state->get<RefBindings>();
 
@@ -3270,7 +3270,7 @@ CFRefCount::ProcessLeaks(const GRState * state,
   return N;
 }
 
-void CFRefCount::EvalEndPath(GRExprEngine& Eng,
+void CFRefCount::evalEndPath(GRExprEngine& Eng,
                              GREndPathNodeBuilder& Builder) {
 
   const GRState *state = Builder.getState();
@@ -3297,7 +3297,7 @@ void CFRefCount::EvalEndPath(GRExprEngine& Eng,
   ProcessLeaks(state, Leaked, Bd, Eng, Pred);
 }
 
-void CFRefCount::EvalDeadSymbols(ExplodedNodeSet& Dst,
+void CFRefCount::evalDeadSymbols(ExplodedNodeSet& Dst,
                                  GRExprEngine& Eng,
                                  GRStmtNodeBuilder& Builder,
                                  ExplodedNode* Pred,
diff --git a/lib/Checker/CStringChecker.cpp b/lib/Checker/CStringChecker.cpp
index c60eca8fc0..2454668f5d 100644
--- a/lib/Checker/CStringChecker.cpp
+++ b/lib/Checker/CStringChecker.cpp
@@ -29,10 +29,10 @@ public:
   {}
   static void *getTag() { static int tag; return &tag; }
 
-  bool EvalCallExpr(CheckerContext &C, const CallExpr *CE);
+  bool evalCallExpr(CheckerContext &C, const CallExpr *CE);
   void PreVisitDeclStmt(CheckerContext &C, const DeclStmt *DS);
   void MarkLiveSymbols(const GRState *state, SymbolReaper &SR);
-  void EvalDeadSymbols(CheckerContext &C, SymbolReaper &SR);
+  void evalDeadSymbols(CheckerContext &C, SymbolReaper &SR);
   bool WantsRegionChangeUpdate(const GRState *state);
 
   const GRState *EvalRegionChanges(const GRState *state,
@@ -42,20 +42,20 @@ public:
 
   typedef void (CStringChecker::*FnCheck)(CheckerContext &, const CallExpr *);
 
-  void EvalMemcpy(CheckerContext &C, const CallExpr *CE);
-  void EvalMemmove(CheckerContext &C, const CallExpr *CE);
-  void EvalBcopy(CheckerContext &C, const CallExpr *CE);
-  void EvalCopyCommon(CheckerContext &C, const GRState *state,
+  void evalMemcpy(CheckerContext &C, const CallExpr *CE);
+  void evalMemmove(CheckerContext &C, const CallExpr *CE);
+  void evalBcopy(CheckerContext &C, const CallExpr *CE);
+  void evalCopyCommon(CheckerContext &C, const GRState *state,
                       const Expr *Size, const Expr *Source, const Expr *Dest,
                       bool Restricted = false);
 
-  void EvalMemcmp(CheckerContext &C, const CallExpr *CE);
+  void evalMemcmp(CheckerContext &C, const CallExpr *CE);
 
-  void EvalStrlen(CheckerContext &C, const CallExpr *CE);
+  void evalStrlen(CheckerContext &C, const CallExpr *CE);
 
-  void EvalStrcpy(CheckerContext &C, const CallExpr *CE);
-  void EvalStpcpy(CheckerContext &C, const CallExpr *CE);
-  void EvalStrcpyCommon(CheckerContext &C, const CallExpr *CE, bool ReturnEnd);
+  void evalStrcpy(CheckerContext &C, const CallExpr *CE);
+  void evalStpcpy(CheckerContext &C, const CallExpr *CE);
+  void evalStrcpyCommon(CheckerContext &C, const CallExpr *CE, bool ReturnEnd);
 
   // Utility methods
   std::pair<const GRState*, const GRState*>
@@ -125,7 +125,7 @@ CStringChecker::AssumeZero(CheckerContext &C, const GRState *state, SVal V,
   SValBuilder &SV = ValMgr.getSValBuilder();
 
   DefinedOrUnknownSVal Zero = ValMgr.makeZeroVal(Ty);
-  DefinedOrUnknownSVal ValIsZero = SV.EvalEQ(state, *Val, Zero);
+  DefinedOrUnknownSVal ValIsZero = SV.evalEQ(state, *Val, Zero);
 
   return state->Assume(ValIsZero);
 }
@@ -265,13 +265,13 @@ const GRState *CStringChecker::CheckBufferAccess(CheckerContext &C,
 
   // Compute the offset of the last element to be accessed: size-1.
   NonLoc One = cast<NonLoc>(VM.makeIntVal(1, SizeTy));
-  NonLoc LastOffset = cast<NonLoc>(SV.EvalBinOpNN(state, BO_Sub,
+  NonLoc LastOffset = cast<NonLoc>(SV.evalBinOpNN(state, BO_Sub,
                                                   *Length, One, SizeTy));
 
   // Check that the first buffer is sufficently long.
-  SVal BufStart = SV.EvalCast(BufVal, PtrTy, FirstBuf->getType());
+  SVal BufStart = SV.evalCast(BufVal, PtrTy, FirstBuf->getType());
   if (Loc *BufLoc = dyn_cast<Loc>(&BufStart)) {
-    SVal BufEnd = SV.EvalBinOpLN(state, BO_Add, *BufLoc,
+    SVal BufEnd = SV.evalBinOpLN(state, BO_Add, *BufLoc,
                                  LastOffset, PtrTy);
     state = CheckLocation(C, state, FirstBuf, BufEnd, FirstIsDestination);
 
@@ -287,9 +287,9 @@ const GRState *CStringChecker::CheckBufferAccess(CheckerContext &C,
     if (!state)
       return NULL;
 
-    BufStart = SV.EvalCast(BufVal, PtrTy, SecondBuf->getType());
+    BufStart = SV.evalCast(BufVal, PtrTy, SecondBuf->getType());
     if (Loc *BufLoc = dyn_cast<Loc>(&BufStart)) {
-      SVal BufEnd = SV.EvalBinOpLN(state, BO_Add, *BufLoc,
+      SVal BufEnd = SV.evalBinOpLN(state, BO_Add, *BufLoc,
                                    LastOffset, PtrTy);
       state = CheckLocation(C, state, SecondBuf, BufEnd);
     }
@@ -330,7 +330,7 @@ const GRState *CStringChecker::CheckOverlap(CheckerContext &C,
     return state;
 
   // Are the two values the same?
-  DefinedOrUnknownSVal EqualTest = SV.EvalEQ(state, *FirstLoc, *SecondLoc);
+  DefinedOrUnknownSVal EqualTest = SV.evalEQ(state, *FirstLoc, *SecondLoc);
   llvm::tie(stateTrue, stateFalse) = state->Assume(EqualTest);
 
   if (stateTrue && !stateFalse) {
@@ -345,7 +345,7 @@ const GRState *CStringChecker::CheckOverlap(CheckerContext &C,
 
   // Which value comes first?
   QualType CmpTy = Ctx.IntTy;
-  SVal Reverse = SV.EvalBinOpLL(state, BO_GT,
+  SVal Reverse = SV.evalBinOpLL(state, BO_GT,
                                 *FirstLoc, *SecondLoc, CmpTy);
   DefinedOrUnknownSVal *ReverseTest = dyn_cast<DefinedOrUnknownSVal>(&Reverse);
   if (!ReverseTest)
@@ -379,20 +379,20 @@ const GRState *CStringChecker::CheckOverlap(CheckerContext &C,
   // Convert the first buffer's start address to char*.
   // Bail out if the cast fails.
   QualType CharPtrTy = Ctx.getPointerType(Ctx.CharTy);
-  SVal FirstStart = SV.EvalCast(*FirstLoc, CharPtrTy, First->getType());
+  SVal FirstStart = SV.evalCast(*FirstLoc, CharPtrTy, First->getType());
   Loc *FirstStartLoc = dyn_cast<Loc>(&FirstStart);
   if (!FirstStartLoc)
     return state;
 
   // Compute the end of the first buffer. Bail out if THAT fails.
-  SVal FirstEnd = SV.EvalBinOpLN(state, BO_Add,
+  SVal FirstEnd = SV.evalBinOpLN(state, BO_Add,
                                  *FirstStartLoc, *Length, CharPtrTy);
   Loc *FirstEndLoc = dyn_cast<Loc>(&FirstEnd);
   if (!FirstEndLoc)
     return state;
 
   // Is the end of the first buffer past the start of the second buffer?
-  SVal Overlap = SV.EvalBinOpLL(state, BO_GT,
+  SVal Overlap = SV.evalBinOpLL(state, BO_GT,
                                 *FirstEndLoc, *SecondLoc, CmpTy);
   DefinedOrUnknownSVal *OverlapTest = dyn_cast<DefinedOrUnknownSVal>(&Overlap);
   if (!OverlapTest)
@@ -647,10 +647,10 @@ bool CStringChecker::SummarizeRegion(llvm::raw_ostream& os, ASTContext& Ctx,
 }
 
 //===----------------------------------------------------------------------===//
-// Evaluation of individual function calls.
+// evaluation of individual function calls.
 //===----------------------------------------------------------------------===//
 
-void CStringChecker::EvalCopyCommon(CheckerContext &C, const GRState *state,
+void CStringChecker::evalCopyCommon(CheckerContext &C, const GRState *state,
                                     const Expr *Size, const Expr *Dest,
                                     const Expr *Source, bool Restricted) {
   // See if the size argument is zero.
@@ -685,30 +685,30 @@ void CStringChecker::EvalCopyCommon(CheckerContext &C, const GRState *state,
 }
 
 
-void CStringChecker::EvalMemcpy(CheckerContext &C, const CallExpr *CE) {
+void CStringChecker::evalMemcpy(CheckerContext &C, const CallExpr *CE) {
   // void *memcpy(void *restrict dst, const void *restrict src, size_t n);
   // The return value is the address of the destination buffer.
   const Expr *Dest = CE->getArg(0);
   const GRState *state = C.getState();
   state = state->BindExpr(CE, state->getSVal(Dest));
-  EvalCopyCommon(C, state, CE->getArg(2), Dest, CE->getArg(1), true);
+  evalCopyCommon(C, state, CE->getArg(2), Dest, CE->getArg(1), true);
 }
 
-void CStringChecker::EvalMemmove(CheckerContext &C, const CallExpr *CE) {
+void CStringChecker::evalMemmove(CheckerContext &C, const CallExpr *CE) {
   // void *memmove(void *dst, const void *src, size_t n);
   // The return value is the address of the destination buffer.
   const Expr *Dest = CE->getArg(0);
   const GRState *state = C.getState();
   state = state->BindExpr(CE, state->getSVal(Dest));
-  EvalCopyCommon(C, state, CE->getArg(2), Dest, CE->getArg(1));
+  evalCopyCommon(C, state, CE->getArg(2), Dest, CE->getArg(1));
 }
 
-void CStringChecker::EvalBcopy(CheckerContext &C, const CallExpr *CE) {
+void CStringChecker::evalBcopy(CheckerContext &C, const CallExpr *CE) {
   // void bcopy(const void *src, void *dst, size_t n);
-  EvalCopyCommon(C, C.getState(), CE->getArg(2), CE->getArg(1), CE->getArg(0));
+  evalCopyCommon(C, C.getState(), CE->getArg(2), CE->getArg(1), CE->getArg(0));
 }
 
-void CStringChecker::EvalMemcmp(CheckerContext &C, const CallExpr *CE) {
+void CStringChecker::evalMemcmp(CheckerContext &C, const CallExpr *CE) {
   // int memcmp(const void *s1, const void *s2, size_t n);
   const Expr *Left = CE->getArg(0);
   const Expr *Right = CE->getArg(1);
@@ -744,7 +744,7 @@ void CStringChecker::EvalMemcmp(CheckerContext &C, const CallExpr *CE) {
     DefinedOrUnknownSVal RV = cast<DefinedOrUnknownSVal>(state->getSVal(Right));
 
     // See if they are the same.
-    DefinedOrUnknownSVal SameBuf = SV.EvalEQ(state, LV, RV);
+    DefinedOrUnknownSVal SameBuf = SV.evalEQ(state, LV, RV);
     const GRState *StSameBuf, *StNotSameBuf;
     llvm::tie(StSameBuf, StNotSameBuf) = state->Assume(SameBuf);
 
@@ -775,7 +775,7 @@ void CStringChecker::EvalMemcmp(CheckerContext &C, const CallExpr *CE) {
   }
 }
 
-void CStringChecker::EvalStrlen(CheckerContext &C, const CallExpr *CE) {
+void CStringChecker::evalStrlen(CheckerContext &C, const CallExpr *CE) {
   // size_t strlen(const char *s);
   const GRState *state = C.getState();
   const Expr *Arg = CE->getArg(0);
@@ -806,17 +806,17 @@ void CStringChecker::EvalStrlen(CheckerContext &C, const CallExpr *CE) {
   }
 }
 
-void CStringChecker::EvalStrcpy(CheckerContext &C, const CallExpr *CE) {
+void CStringChecker::evalStrcpy(CheckerContext &C, const CallExpr *CE) {
   // char *strcpy(char *restrict dst, const char *restrict src);
-  EvalStrcpyCommon(C, CE, /* ReturnEnd = */ false);
+  evalStrcpyCommon(C, CE, /* ReturnEnd = */ false);
 }
 
-void CStringChecker::EvalStpcpy(CheckerContext &C, const CallExpr *CE) {
+void CStringChecker::evalStpcpy(CheckerContext &C, const CallExpr *CE) {
   // char *stpcpy(char *restrict dst, const char *restrict src);
-  EvalStrcpyCommon(C, CE, /* ReturnEnd = */ true);
+  evalStrcpyCommon(C, CE, /* ReturnEnd = */ true);
 }
 
-void CStringChecker::EvalStrcpyCommon(CheckerContext &C, const CallExpr *CE,
+void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallExpr *CE,
                                       bool ReturnEnd) {
   const GRState *state = C.getState();
 
@@ -852,7 +852,7 @@ void CStringChecker::EvalStrcpyCommon(CheckerContext &C, const CallExpr *CE,
     if (NonLoc *KnownStrLen = dyn_cast<NonLoc>(&StrLen)) {
       SValBuilder &SV = C.getSValBuilder();
 
-      SVal LastElement = SV.EvalBinOpLN(state, BO_Add,
+      SVal LastElement = SV.evalBinOpLN(state, BO_Add,
                                         *DstRegVal, *KnownStrLen,
                                         Dst->getType());
 
@@ -894,7 +894,7 @@ void CStringChecker::EvalStrcpyCommon(CheckerContext &C, const CallExpr *CE,
 // The driver method, and other Checker callbacks.
 //===----------------------------------------------------------------------===//
 
-bool CStringChecker::EvalCallExpr(CheckerContext &C, const CallExpr *CE) {
+bool CStringChecker::evalCallExpr(CheckerContext &C, const CallExpr *CE) {
   // Get the callee.  All the functions we care about are C functions
   // with simple identifiers.
   const GRState *state = C.getState();
@@ -912,22 +912,22 @@ bool CStringChecker::EvalCallExpr(CheckerContext &C, const CallExpr *CE) {
   if (Name.startswith("__builtin_"))
     Name = Name.substr(10);
 
-  FnCheck EvalFunction = llvm::StringSwitch<FnCheck>(Name)
-    .Cases("memcpy", "__memcpy_chk", &CStringChecker::EvalMemcpy)
-    .Cases("memcmp", "bcmp", &CStringChecker::EvalMemcmp)
-    .Cases("memmove", "__memmove_chk", &CStringChecker::EvalMemmove)
-    .Cases("strcpy", "__strcpy_chk", &CStringChecker::EvalStrcpy)
-    .Cases("stpcpy", "__stpcpy_chk", &CStringChecker::EvalStpcpy)
-    .Case("strlen", &CStringChecker::EvalStrlen)
-    .Case("bcopy", &CStringChecker::EvalBcopy)
+  FnCheck evalFunction = llvm::StringSwitch<FnCheck>(Name)
+    .Cases("memcpy", "__memcpy_chk", &CStringChecker::evalMemcpy)
+    .Cases("memcmp", "bcmp", &CStringChecker::evalMemcmp)
+    .Cases("memmove", "__memmove_chk", &CStringChecker::evalMemmove)
+    .Cases("strcpy", "__strcpy_chk", &CStringChecker::evalStrcpy)
+    .Cases("stpcpy", "__stpcpy_chk", &CStringChecker::evalStpcpy)
+    .Case("strlen", &CStringChecker::evalStrlen)
+    .Case("bcopy", &CStringChecker::evalBcopy)
     .Default(NULL);
 
   // If the callee isn't a string function, let another checker handle it.
-  if (!EvalFunction)
+  if (!evalFunction)
     return false;
 
   // Check and evaluate the call.
-  (this->*EvalFunction)(C, CE);
+  (this->*evalFunction)(C, CE);
   return true;
 }
 
@@ -1034,7 +1034,7 @@ void CStringChecker::MarkLiveSymbols(const GRState *state, SymbolReaper &SR) {
   }
 }
 
-void CStringChecker::EvalDeadSymbols(CheckerContext &C, SymbolReaper &SR) {
+void CStringChecker::evalDeadSymbols(CheckerContext &C, SymbolReaper &SR) {
   if (!SR.hasDeadSymbols())
     return;
 
diff --git a/lib/Checker/CallAndMessageChecker.cpp b/lib/Checker/CallAndMessageChecker.cpp
index be09e51b75..9e5a67ae05 100644
--- a/lib/Checker/CallAndMessageChecker.cpp
+++ b/lib/Checker/CallAndMessageChecker.cpp
@@ -41,7 +41,7 @@ public:
 
   void PreVisitCallExpr(CheckerContext &C, const CallExpr *CE);
   void PreVisitObjCMessageExpr(CheckerContext &C, const ObjCMessageExpr *ME);
-  bool EvalNilReceiver(CheckerContext &C, const ObjCMessageExpr *ME);
+  bool evalNilReceiver(CheckerContext &C, const ObjCMessageExpr *ME);
 
 private:
   bool PreVisitProcessArg(CheckerContext &C, const Expr *Ex,
@@ -244,7 +244,7 @@ void CallAndMessageChecker::PreVisitObjCMessageExpr(CheckerContext &C,
         return;
 }
 
-bool CallAndMessageChecker::EvalNilReceiver(CheckerContext &C,
+bool CallAndMessageChecker::evalNilReceiver(CheckerContext &C,
                                             const ObjCMessageExpr *ME) {
   HandleNilReceiver(C, C.getState(), ME);
   return true; // Nil receiver is not handled elsewhere.
diff --git a/lib/Checker/ChrootChecker.cpp b/lib/Checker/ChrootChecker.cpp
index 763a6d3923..d0ec94be8e 100644
--- a/lib/Checker/ChrootChecker.cpp
+++ b/lib/Checker/ChrootChecker.cpp
@@ -48,7 +48,7 @@ public:
     return &x;
   }
   
-  virtual bool EvalCallExpr(CheckerContext &C, const CallExpr *CE);
+  virtual bool evalCallExpr(CheckerContext &C, const CallExpr *CE);
   virtual void PreVisitCallExpr(CheckerContext &C, const CallExpr *CE);
 
 private:
@@ -62,7 +62,7 @@ void clang::RegisterChrootChecker(GRExprEngine &Eng) {
   Eng.registerCheck(new ChrootChecker());
 }
 
-bool ChrootChecker::EvalCallExpr(CheckerContext &C, const CallExpr *CE) {
+bool ChrootChecker::evalCallExpr(CheckerContext &C, const CallExpr *CE) {
   const GRState *state = C.getState();
   const Expr *Callee = CE->getCallee();
   SVal L = state->getSVal(Callee);
diff --git a/lib/Checker/GRCXXExprEngine.cpp b/lib/Checker/GRCXXExprEngine.cpp
index a60af37c0a..20d2fa7790 100644
--- a/lib/Checker/GRCXXExprEngine.cpp
+++ b/lib/Checker/GRCXXExprEngine.cpp
@@ -28,7 +28,7 @@ public:
 };
 }
 
-void GRExprEngine::EvalArguments(ConstExprIterator AI, ConstExprIterator AE,
+void GRExprEngine::evalArguments(ConstExprIterator AI, ConstExprIterator AE,
                                  const FunctionProtoType *FnType, 
                                  ExplodedNode *Pred, ExplodedNodeSet &Dst,
                                  bool FstArgAsLValue) {
@@ -125,9 +125,9 @@ void GRExprEngine::VisitCXXConstructExpr(const CXXConstructExpr *E,
 
   
   // Evaluate other arguments.
-  ExplodedNodeSet ArgsEvaluated;
+  ExplodedNodeSet argsEvaluated;
   const FunctionProtoType *FnType = CD->getType()->getAs<FunctionProtoType>();
-  EvalArguments(E->arg_begin(), E->arg_end(), FnType, Pred, ArgsEvaluated);
+  evalArguments(E->arg_begin(), E->arg_end(), FnType, Pred, argsEvaluated);
   // The callee stack frame context used to create the 'this' parameter region.
   const StackFrameContext *SFC = AMgr.getStackFrame(CD, 
                                                     Pred->getLocationContext(),
@@ -137,8 +137,8 @@ void GRExprEngine::VisitCXXConstructExpr(const CXXConstructExpr *E,
                                                SFC);
 
   CallEnter Loc(E, SFC, Pred->getLocationContext());
-  for (ExplodedNodeSet::iterator NI = ArgsEvaluated.begin(),
-                                 NE = ArgsEvaluated.end(); NI != NE; ++NI) {
+  for (ExplodedNodeSet::iterator NI = argsEvaluated.begin(),
+                                 NE = argsEvaluated.end(); NI != NE; ++NI) {
     const GRState *state = GetState(*NI);
     // Setup 'this' region, so that the ctor is evaluated on the object pointed
     // by 'Dest'.
@@ -182,27 +182,27 @@ void GRExprEngine::VisitCXXMemberCallExpr(const CXXMemberCallExpr *MCE,
   assert(FnType && "Method type not available");
 
   // Evaluate explicit arguments with a worklist.
-  ExplodedNodeSet ArgsEvaluated;
-  EvalArguments(MCE->arg_begin(), MCE->arg_end(), FnType, Pred, ArgsEvaluated);
+  ExplodedNodeSet argsEvaluated;
+  evalArguments(MCE->arg_begin(), MCE->arg_end(), FnType, Pred, argsEvaluated);
  
   // Evaluate the implicit object argument.
-  ExplodedNodeSet AllArgsEvaluated;
+  ExplodedNodeSet AllargsEvaluated;
   const MemberExpr *ME = dyn_cast<MemberExpr>(MCE->getCallee()->IgnoreParens());
   if (!ME)
     return;
   Expr *ObjArgExpr = ME->getBase();
-  for (ExplodedNodeSet::iterator I = ArgsEvaluated.begin(), 
-                                 E = ArgsEvaluated.end(); I != E; ++I) {
+  for (ExplodedNodeSet::iterator I = argsEvaluated.begin(), 
+                                 E = argsEvaluated.end(); I != E; ++I) {
     if (ME->isArrow())
-      Visit(ObjArgExpr, *I, AllArgsEvaluated);
+      Visit(ObjArgExpr, *I, AllargsEvaluated);
     else
-      VisitLValue(ObjArgExpr, *I, AllArgsEvaluated);
+      VisitLValue(ObjArgExpr, *I, AllargsEvaluated);
   }
 
   // Now evaluate the call itself.
   const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl());
   assert(MD && "not a CXXMethodDecl?");
-  EvalMethodCall(MCE, MD, ObjArgExpr, Pred, AllArgsEvaluated, Dst);
+  evalMethodCall(MCE, MD, ObjArgExpr, Pred, AllargsEvaluated, Dst);
 }
 
 void GRExprEngine::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *C,
@@ -223,14 +223,14 @@ void GRExprEngine::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *C,
 
   // Evaluate arguments treating the first one (object method is called on)
   // as alvalue.
-  ExplodedNodeSet ArgsEvaluated;
-  EvalArguments(C->arg_begin(), C->arg_end(), Proto, Pred, ArgsEvaluated, true);
+  ExplodedNodeSet argsEvaluated;
+  evalArguments(C->arg_begin(), C->arg_end(), Proto, Pred, argsEvaluated, true);
 
   // Now evaluate the call itself.
-  EvalMethodCall(C, MD, C->getArg(0), Pred, ArgsEvaluated, Dst);
+  evalMethodCall(C, MD, C->getArg(0), Pred, argsEvaluated, Dst);
 }
 
-void GRExprEngine::EvalMethodCall(const CallExpr *MCE, const CXXMethodDecl *MD,
+void GRExprEngine::evalMethodCall(const CallExpr *MCE, const CXXMethodDecl *MD,
                                   const Expr *ThisExpr, ExplodedNode *Pred,
                                   ExplodedNodeSet &Src, ExplodedNodeSet &Dst) {
   // Allow checkers to pre-visit the member call.
@@ -281,13 +281,13 @@ void GRExprEngine::VisitCXXNewExpr(const CXXNewExpr *CNE, ExplodedNode *Pred,
   const CXXConstructorDecl *CD = CNE->getConstructor();
   if (CD)
     FnType = CD->getType()->getAs<FunctionProtoType>();
-  ExplodedNodeSet ArgsEvaluated;
-  EvalArguments(CNE->constructor_arg_begin(), CNE->constructor_arg_end(),
-                FnType, Pred, ArgsEvaluated);
+  ExplodedNodeSet argsEvaluated;
+  evalArguments(CNE->constructor_arg_begin(), CNE->constructor_arg_end(),
+                FnType, Pred, argsEvaluated);
 
   // Initialize the object region and bind the 'new' expression.
-  for (ExplodedNodeSet::iterator I = ArgsEvaluated.begin(), 
-                                 E = ArgsEvaluated.end(); I != E; ++I) {
+  for (ExplodedNodeSet::iterator I = argsEvaluated.begin(), 
+                                 E = argsEvaluated.end(); I != E; ++I) {
     const GRState *state = GetState(*I);
 
     if (ObjTy->isRecordType()) {
@@ -310,10 +310,10 @@ void GRExprEngine::VisitCXXNewExpr(const CXXNewExpr *CNE, ExplodedNode *Pred,
 void GRExprEngine::VisitCXXDeleteExpr(const CXXDeleteExpr *CDE, 
                                       ExplodedNode *Pred,ExplodedNodeSet &Dst) {
   // Should do more checking.
-  ExplodedNodeSet ArgEvaluated;
-  Visit(CDE->getArgument(), Pred, ArgEvaluated);
-  for (ExplodedNodeSet::iterator I = ArgEvaluated.begin(), 
-                                 E = ArgEvaluated.end(); I != E; ++I) {
+  ExplodedNodeSet Argevaluated;
+  Visit(CDE->getArgument(), Pred, Argevaluated);
+  for (ExplodedNodeSet::iterator I = Argevaluated.begin(), 
+                                 E = Argevaluated.end(); I != E; ++I) {
     const GRState *state = GetState(*I);
     MakeNode(Dst, CDE, *I, state);
   }
diff --git a/lib/Checker/GRExprEngine.cpp b/lib/Checker/GRExprEngine.cpp
index 3aa087b52c..1afad76558 100644
--- a/lib/Checker/GRExprEngine.cpp
+++ b/lib/Checker/GRExprEngine.cpp
@@ -186,23 +186,23 @@ void GRExprEngine::CheckerEvalNilReceiver(const ObjCMessageExpr *ME,
                                           ExplodedNodeSet &Dst,
                                           const GRState *state,
                                           ExplodedNode *Pred) {
-  boo