1 files changed, 26 insertions, 26 deletions

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);
   }