STYLE: Fix some style issues

43 files changed, 1788 insertions, 1708 deletions

diff --git a/Source/CTest/cmCTestBuildAndTestHandler.cxx b/Source/CTest/cmCTestBuildAndTestHandler.cxx
index ab89961..3652f8d 100644
--- a/Source/CTest/cmCTestBuildAndTestHandler.cxx
+++ b/Source/CTest/cmCTestBuildAndTestHandler.cxx
@@ -26,30 +26,31 @@
 //----------------------------------------------------------------------
 cmCTestBuildAndTestHandler::cmCTestBuildAndTestHandler()
 {
-  m_BuildTwoConfig         = false;
-  m_BuildNoClean           = false;
-  m_BuildNoCMake           = false;
+  this->BuildTwoConfig         = false;
+  this->BuildNoClean           = false;
+  this->BuildNoCMake           = false;
 }
 
 //----------------------------------------------------------------------
 void cmCTestBuildAndTestHandler::Initialize()
 {
-  m_BuildTargets.erase(m_BuildTargets.begin(), m_BuildTargets.end());
+  this->BuildTargets.erase(
+    this->BuildTargets.begin(), this->BuildTargets.end());
   this->Superclass::Initialize();
 }
 
 //----------------------------------------------------------------------
 const char* cmCTestBuildAndTestHandler::GetOutput()
 {
-  return m_Output.c_str();
+  return this->Output.c_str();
 }
 //----------------------------------------------------------------------
 int cmCTestBuildAndTestHandler::ProcessHandler()
 {
-  m_Output = "";
+  this->Output = "";
   std::string output;
   cmSystemTools::ResetErrorOccuredFlag();
-  int retv = this->RunCMakeAndTest(&m_Output);
+  int retv = this->RunCMakeAndTest(&this->Output);
   cmSystemTools::ResetErrorOccuredFlag();
   return retv;
 }
@@ -61,24 +62,24 @@ int cmCTestBuildAndTestHandler::RunCMake(std::string* outstring,
 {
   unsigned int k;
   std::vector<std::string> args;
-  args.push_back(m_CTest->GetCMakeExecutable());
-  args.push_back(m_SourceDir);
-  if(m_BuildGenerator.size())
+  args.push_back(this->CTest->GetCMakeExecutable());
+  args.push_back(this->SourceDir);
+  if(this->BuildGenerator.size())
     {
     std::string generator = "-G";
-    generator += m_BuildGenerator;
+    generator += this->BuildGenerator;
     args.push_back(generator);
     }
-  if ( m_CTest->GetConfigType().size() > 0 )
+  if ( this->CTest->GetConfigType().size() > 0 )
     {
     std::string btype
-      = "-DCMAKE_BUILD_TYPE:STRING=" + m_CTest->GetConfigType();
+      = "-DCMAKE_BUILD_TYPE:STRING=" + this->CTest->GetConfigType();
     args.push_back(btype);
     }
 
-  for(k=0; k < m_BuildOptions.size(); ++k)
+  for(k=0; k < this->BuildOptions.size(); ++k)
     {
-    args.push_back(m_BuildOptions[k]);
+    args.push_back(this->BuildOptions[k]);
     }
   if (cm->Run(args) != 0)
     {
@@ -92,12 +93,12 @@ int cmCTestBuildAndTestHandler::RunCMake(std::string* outstring,
       }
     else
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, out.str() << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE, out.str() << std::endl);
       }
     return 1;
     }
   // do another config?
-  if(m_BuildTwoConfig)
+  if(this->BuildTwoConfig)
     {
     if (cm->Run(args) != 0)
       {
@@ -111,7 +112,7 @@ int cmCTestBuildAndTestHandler::RunCMake(std::string* outstring,
         }
       else
         {
-        cmCTestLog(m_CTest, ERROR_MESSAGE, out.str() << std::endl);
+        cmCTestLog(this->CTest, ERROR_MESSAGE, out.str() << std::endl);
         }
       return 1;
       }
@@ -142,11 +143,11 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
   cmSystemTools::SetErrorCallback(CMakeMessageCallback, &cmakeOutString);
   cmSystemTools::SetStdoutCallback(CMakeStdoutCallback, &cmakeOutString);
   cmOStringStream out;
-  // What is this? double timeout = m_CTest->GetTimeOut();
+  // What is this? double timeout = this->CTest->GetTimeOut();
   int retVal = 0;
 
   // if the generator and make program are not specified then it is an error
-  if (!m_BuildGenerator.size() || !m_BuildMakeProgram.size())
+  if (!this->BuildGenerator.size() || !this->BuildMakeProgram.size())
     {
     if(outstring)
       {
@@ -160,18 +161,20 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
 
   // make sure the binary dir is there
   std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
-  out << "Internal cmake changing into directory: " << m_BinaryDir << "\n";
-  if (!cmSystemTools::FileIsDirectory(m_BinaryDir.c_str()))
+  out << "Internal cmake changing into directory: "
+    << this->BinaryDir << std::endl;
+  if (!cmSystemTools::FileIsDirectory(this->BinaryDir.c_str()))
     {
-    cmSystemTools::MakeDirectory(m_BinaryDir.c_str());
+    cmSystemTools::MakeDirectory(this->BinaryDir.c_str());
     }
-  cmSystemTools::ChangeDirectory(m_BinaryDir.c_str());
+  cmSystemTools::ChangeDirectory(this->BinaryDir.c_str());
 
   // should we cmake?
   cmake cm;
-  cm.SetGlobalGenerator(cm.CreateGlobalGenerator(m_BuildGenerator.c_str()));
+  cm.SetGlobalGenerator(cm.CreateGlobalGenerator(
+      this->BuildGenerator.c_str()));
 
-  if(!m_BuildNoCMake)
+  if(!this->BuildNoCMake)
     {
     // do the cmake step
     if (this->RunCMake(outstring,out,cmakeOutString,cwd,&cm))
@@ -182,19 +185,19 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
 
   // do the build
   std::vector<std::string>::iterator tarIt;
-  if ( m_BuildTargets.size() == 0 )
+  if ( this->BuildTargets.size() == 0 )
     {
-    m_BuildTargets.push_back("");
+    this->BuildTargets.push_back("");
     }
-  for ( tarIt = m_BuildTargets.begin(); tarIt != m_BuildTargets.end();
+  for ( tarIt = this->BuildTargets.begin(); tarIt != this->BuildTargets.end();
     ++ tarIt )
     {
     std::string output;
     retVal = cm.GetGlobalGenerator()->Build(
-      m_SourceDir.c_str(), m_BinaryDir.c_str(),
-      m_BuildProject.c_str(), tarIt->c_str(),
-      &output, m_BuildMakeProgram.c_str(),
-      m_CTest->GetConfigType().c_str(),!m_BuildNoClean);
+      this->SourceDir.c_str(), this->BinaryDir.c_str(),
+      this->BuildProject.c_str(), tarIt->c_str(),
+      &output, this->BuildMakeProgram.c_str(),
+      this->CTest->GetConfigType().c_str(),!this->BuildNoClean);
 
     out << output;
     // if the build failed then return
@@ -213,7 +216,7 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
     }
 
   // if not test was specified then we are done
-  if (!m_TestCommand.size())
+  if (!this->TestCommand.size())
     {
     return 0;
     }
@@ -223,9 +226,9 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
   std::vector<std::string> failed;
   std::string tempPath;
   std::string filepath =
-    cmSystemTools::GetFilenamePath(m_TestCommand);
+    cmSystemTools::GetFilenamePath(this->TestCommand);
   std::string filename =
-    cmSystemTools::GetFilenameName(m_TestCommand);
+    cmSystemTools::GetFilenameName(this->TestCommand);
   // if full path specified then search that first
   if (filepath.size())
     {
@@ -233,17 +236,17 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
     tempPath += "/";
     tempPath += filename;
     attempted.push_back(tempPath);
-    if(m_CTest->GetConfigType().size())
+    if(this->CTest->GetConfigType().size())
       {
       tempPath = filepath;
       tempPath += "/";
-      tempPath += m_CTest->GetConfigType();
+      tempPath += this->CTest->GetConfigType();
       tempPath += "/";
       tempPath += filename;
       attempted.push_back(tempPath);
       // If the file is an OSX bundle then the configtyp
       // will be at the start of the path
-      tempPath = m_CTest->GetConfigType();
+      tempPath = this->CTest->GetConfigType();
       tempPath += "/";
       tempPath += filepath;
       tempPath += "/";
@@ -255,26 +258,26 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
   else
     {
     attempted.push_back(filename);
-    if(m_CTest->GetConfigType().size())
+    if(this->CTest->GetConfigType().size())
       {
-      tempPath = m_CTest->GetConfigType();
+      tempPath = this->CTest->GetConfigType();
       tempPath += "/";
       tempPath += filename;
       attempted.push_back(tempPath);
       }
     }
-  // if m_ExecutableDirectory is set try that as well
-  if (m_ExecutableDirectory.size())
+  // if this->ExecutableDirectory is set try that as well
+  if (this->ExecutableDirectory.size())
     {
-    tempPath = m_ExecutableDirectory;
+    tempPath = this->ExecutableDirectory;
     tempPath += "/";
-    tempPath += m_TestCommand;
+    tempPath += this->TestCommand;
     attempted.push_back(tempPath);
-    if(m_CTest->GetConfigType().size())
+    if(this->CTest->GetConfigType().size())
       {
-      tempPath = m_ExecutableDirectory;
+      tempPath = this->ExecutableDirectory;
       tempPath += "/";
-      tempPath += m_CTest->GetConfigType();
+      tempPath += this->CTest->GetConfigType();
       tempPath += "/";
       tempPath += filename;
       attempted.push_back(tempPath);
@@ -314,8 +317,8 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
 
   if(!cmSystemTools::FileExists(fullPath.c_str()))
     {
-    out << "Could not find path to executable, perhaps it was not built: " <<
-      m_TestCommand << "\n";
+    out << "Could not find path to executable, perhaps it was not built: "
+      << this->TestCommand << "\n";
     out << "tried to find it in these places:\n";
     out << fullPath.c_str() << "\n";
     for(unsigned int i=0; i < failed.size(); ++i)
@@ -328,7 +331,7 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
       }
     else
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, out.str());
+      cmCTestLog(this->CTest, ERROR_MESSAGE, out.str());
       }
     // return to the original directory
     cmSystemTools::ChangeDirectory(cwd.c_str());
@@ -337,27 +340,27 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
 
   std::vector<const char*> testCommand;
   testCommand.push_back(fullPath.c_str());
-  for(k=0; k < m_TestCommandArgs.size(); ++k)
+  for(k=0; k < this->TestCommandArgs.size(); ++k)
     {
-    testCommand.push_back(m_TestCommandArgs[k].c_str());
+    testCommand.push_back(this->TestCommandArgs[k].c_str());
     }
   testCommand.push_back(0);
   std::string outs;
   int retval = 0;
-  // run the test from the m_BuildRunDir if set
-  if(m_BuildRunDir.size())
+  // run the test from the this->BuildRunDir if set
+  if(this->BuildRunDir.size())
     {
-    out << "Run test in directory: " << m_BuildRunDir << "\n";
-    cmSystemTools::ChangeDirectory(m_BuildRunDir.c_str());
+    out << "Run test in directory: " << this->BuildRunDir << "\n";
+    cmSystemTools::ChangeDirectory(this->BuildRunDir.c_str());
     }
   out << "Running test executable: " << fullPath << " ";
-  for(k=0; k < m_TestCommandArgs.size(); ++k)
+  for(k=0; k < this->TestCommandArgs.size(); ++k)
     {
-    out << m_TestCommandArgs[k] << " ";
+    out << this->TestCommandArgs[k] << " ";
     }
   out << "\n";
-  // What is this? m_TimeOut = timeout;
-  int runTestRes = m_CTest->RunTest(testCommand, &outs, &retval, 0);
+  // What is this? this->TimeOut = timeout;
+  int runTestRes = this->CTest->RunTest(testCommand, &outs, &retval, 0);
   if(runTestRes != cmsysProcess_State_Exited || retval != 0)
     {
     out << "Failed to run test command: " << testCommand[0] << "\n";
@@ -371,7 +374,7 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
     }
   else
     {
-    cmCTestLog(m_CTest, OUTPUT, out.str() << std::endl);
+    cmCTestLog(this->CTest, OUTPUT, out.str() << std::endl);
     }
   return retval;
 }
@@ -387,17 +390,19 @@ int cmCTestBuildAndTestHandler::ProcessCommandLineArguments(
     if(idx+2 < allArgs.size())
       {
       idx++;
-      m_SourceDir = allArgs[idx];
+      this->SourceDir = allArgs[idx];
       idx++;
-      m_BinaryDir = allArgs[idx];
+      this->BinaryDir = allArgs[idx];
       // dir must exist before CollapseFullPath is called
-      cmSystemTools::MakeDirectory(m_BinaryDir.c_str());
-      m_BinaryDir = cmSystemTools::CollapseFullPath(m_BinaryDir.c_str());
-      m_SourceDir = cmSystemTools::CollapseFullPath(m_SourceDir.c_str());
+      cmSystemTools::MakeDirectory(this->BinaryDir.c_str());
+      this->BinaryDir
+        = cmSystemTools::CollapseFullPath(this->BinaryDir.c_str());
+      this->SourceDir
+        = cmSystemTools::CollapseFullPath(this->SourceDir.c_str());
       }
     else
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE,
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
         "--build-and-test must have source and binary dir" << std::endl);
       return 0;
       }
@@ -405,45 +410,45 @@ int cmCTestBuildAndTestHandler::ProcessCommandLineArguments(
   if(currentArg.find("--build-target",0) == 0 && idx < allArgs.size() - 1)
     {
     idx++;
-    m_BuildTargets.push_back(allArgs[idx]);
+    this->BuildTargets.push_back(allArgs[idx]);
     }
   if(currentArg.find("--build-nocmake",0) == 0)
     {
-    m_BuildNoCMake = true;
+    this->BuildNoCMake = true;
     }
   if(currentArg.find("--build-run-dir",0) == 0 && idx < allArgs.size() - 1)
     {
     idx++;
-    m_BuildRunDir = allArgs[idx];
+    this->BuildRunDir = allArgs[idx];
     }
   if(currentArg.find("--build-two-config",0) == 0)
     {
-    m_BuildTwoConfig = true;
+    this->BuildTwoConfig = true;
     }
   if(currentArg.find("--build-exe-dir",0) == 0 && idx < allArgs.size() - 1)
     {
     idx++;
-    m_ExecutableDirectory = allArgs[idx];
+    this->ExecutableDirectory = allArgs[idx];
     }
   if(currentArg.find("--build-generator",0) == 0 && idx < allArgs.size() - 1)
     {
     idx++;
-    m_BuildGenerator = allArgs[idx];
+    this->BuildGenerator = allArgs[idx];
     }
   if(currentArg.find("--build-project",0) == 0 && idx < allArgs.size() - 1)
     {
     idx++;
-    m_BuildProject = allArgs[idx];
+    this->BuildProject = allArgs[idx];
     }
   if(currentArg.find("--build-makeprogram",0) == 0 &&
     idx < allArgs.size() - 1)
     {
     idx++;
-    m_BuildMakeProgram = allArgs[idx];
+    this->BuildMakeProgram = allArgs[idx];
     }
   if(currentArg.find("--build-noclean",0) == 0)
     {
-    m_BuildNoClean = true;
+    this->BuildNoClean = true;
     }
   if(currentArg.find("--build-options",0) == 0 && idx < allArgs.size() - 1)
     {
@@ -451,7 +456,7 @@ int cmCTestBuildAndTestHandler::ProcessCommandLineArguments(
     bool done = false;
     while(idx < allArgs.size() && !done)
       {
-      m_BuildOptions.push_back(allArgs[idx]);
+      this->BuildOptions.push_back(allArgs[idx]);
       if(idx+1 < allArgs.size()
         && (allArgs[idx+1] == "--build-target" ||
           allArgs[idx+1] == "--test-command"))
@@ -467,11 +472,11 @@ int cmCTestBuildAndTestHandler::ProcessCommandLineArguments(
   if(currentArg.find("--test-command",0) == 0 && idx < allArgs.size() - 1)
     {
     ++idx;
-    m_TestCommand = allArgs[idx];
+    this->TestCommand = allArgs[idx];
     while(idx+1 < allArgs.size())
       {
       ++idx;
-      m_TestCommandArgs.push_back(allArgs[idx]);
+      this->TestCommandArgs.push_back(allArgs[idx]);
       }
     }
   return 1;
diff --git a/Source/CTest/cmCTestBuildAndTestHandler.h b/Source/CTest/cmCTestBuildAndTestHandler.h
index d2ec82f..073760d 100644
--- a/Source/CTest/cmCTestBuildAndTestHandler.h
+++ b/Source/CTest/cmCTestBuildAndTestHandler.h
@@ -59,22 +59,22 @@ protected:
                std::string &cmakeOutString,
                std::string &cwd, cmake *cm);
   
-  cmStdString  m_Output;
-
-  std::string              m_BuildGenerator;
-  std::vector<std::string> m_BuildOptions;
-  bool                     m_BuildTwoConfig;
-  std::string              m_BuildMakeProgram;
-  std::string              m_SourceDir;
-  std::string              m_BinaryDir;
-  std::string              m_BuildProject;
-  std::string              m_TestCommand;
-  bool                     m_BuildNoClean;
-  std::string              m_BuildRunDir;
-  std::string              m_ExecutableDirectory;
-  std::vector<std::string> m_TestCommandArgs;
-  std::vector<std::string> m_BuildTargets;
-  bool                     m_BuildNoCMake;
+  cmStdString  Output;
+
+  std::string              BuildGenerator;
+  std::vector<std::string> BuildOptions;
+  bool                     BuildTwoConfig;
+  std::string              BuildMakeProgram;
+  std::string              SourceDir;
+  std::string              BinaryDir;
+  std::string              BuildProject;
+  std::string              TestCommand;
+  bool                     BuildNoClean;
+  std::string              BuildRunDir;
+  std::string              ExecutableDirectory;
+  std::vector<std::string> TestCommandArgs;
+  std::vector<std::string> BuildTargets;
+  bool                     BuildNoCMake;
 };
 
 #endif
diff --git a/Source/CTest/cmCTestBuildCommand.cxx b/Source/CTest/cmCTestBuildCommand.cxx
index 361bf66..91cb366 100644
--- a/Source/CTest/cmCTestBuildCommand.cxx
+++ b/Source/CTest/cmCTestBuildCommand.cxx
@@ -25,16 +25,16 @@
 //----------------------------------------------------------------------------
 cmCTestBuildCommand::cmCTestBuildCommand()
 {
-  m_GlobalGenerator = 0;
+  this->GlobalGenerator = 0;
 }
 
 //----------------------------------------------------------------------------
 cmCTestBuildCommand::~cmCTestBuildCommand()
 {
-  if ( m_GlobalGenerator )
+  if ( this->GlobalGenerator )
     {
-    delete m_GlobalGenerator;
-    m_GlobalGenerator = 0;
+    delete this->GlobalGenerator;
+    this->GlobalGenerator = 0;
     }
 }
 
@@ -91,10 +91,11 @@ bool cmCTestBuildCommand::InitialPass(
 
   if ( build_dir )
     {
-    m_CTest->SetCTestConfiguration("BuildDirectory", build_dir);
+    this->CTest->SetCTestConfiguration("BuildDirectory", build_dir);
     }
 
-  cmCTestGenericHandler* handler = m_CTest->GetInitializedHandler("build");
+  cmCTestGenericHandler* handler
+    = this->CTest->GetInitializedHandler("build");
   if ( !handler )
     {
     this->SetError("internal CTest error. Cannot instantiate build handler");
@@ -105,7 +106,7 @@ bool cmCTestBuildCommand::InitialPass(
     = m_Makefile->GetDefinition("CTEST_BUILD_COMMAND");
   if ( ctestBuildCommand && *ctestBuildCommand )
     {
-    m_CTest->SetCTestConfiguration("MakeCommand", ctestBuildCommand);
+    this->CTest->SetCTestConfiguration("MakeCommand", ctestBuildCommand);
     }
   else
     {
@@ -124,28 +125,29 @@ bool cmCTestBuildCommand::InitialPass(
         {
         cmakeBuildConfiguration = "Release";
         }
-      if ( m_GlobalGenerator )
+      if ( this->GlobalGenerator )
         {
-        if ( strcmp(m_GlobalGenerator->GetName(), cmakeGeneratorName) != 0 )
+        if ( strcmp(this->GlobalGenerator->GetName(),
+            cmakeGeneratorName) != 0 )
           {
-          delete m_GlobalGenerator;
-          m_GlobalGenerator = 0;
+          delete this->GlobalGenerator;
+          this->GlobalGenerator = 0;
           }
         }
-      if ( !m_GlobalGenerator )
+      if ( !this->GlobalGenerator )
         {
-        m_GlobalGenerator =
+        this->GlobalGenerator =
           m_Makefile->GetCMakeInstance()->CreateGlobalGenerator(
             cmakeGeneratorName);
         }
-      m_GlobalGenerator->FindMakeProgram(m_Makefile);
+      this->GlobalGenerator->FindMakeProgram(m_Makefile);
       const char* cmakeMakeProgram
         = m_Makefile->GetDefinition("CMAKE_MAKE_PROGRAM");
       std::string buildCommand
-        = m_GlobalGenerator->GenerateBuildCommand(cmakeMakeProgram,
+        = this->GlobalGenerator->GenerateBuildCommand(cmakeMakeProgram,
           cmakeProjectName,
           cmakeBuildAdditionalFlags, 0, cmakeBuildConfiguration, true);
-      m_CTest->SetCTestConfiguration("MakeCommand", buildCommand.c_str());
+      this->CTest->SetCTestConfiguration("MakeCommand", buildCommand.c_str());
       }
     else
       {
diff --git a/Source/CTest/cmCTestBuildCommand.h b/Source/CTest/cmCTestBuildCommand.h
index 0607863..3f4c87a 100644
--- a/Source/CTest/cmCTestBuildCommand.h
+++ b/Source/CTest/cmCTestBuildCommand.h
@@ -9,8 +9,8 @@
   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
 
-     This software is distributed WITHOUT ANY WARRANTY; without even 
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
      PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
@@ -32,15 +32,15 @@ public:
 
   cmCTestBuildCommand();
   ~cmCTestBuildCommand();
-  
+
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() 
+  virtual cmCommand* Clone()
     {
     cmCTestBuildCommand* ni = new cmCTestBuildCommand;
-    ni->m_CTest = this->m_CTest;
-    ni->m_CTestScriptHandler = this->m_CTestScriptHandler;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
     }
 
@@ -58,11 +58,11 @@ public:
   /**
    * Succinct documentation.
    */
-  virtual const char* GetTerseDocumentation() 
+  virtual const char* GetTerseDocumentation()
     {
     return "Builds the repository.";
     }
-  
+
   /**
    * More documentation.
    */
@@ -75,7 +75,7 @@ public:
 
   cmTypeMacro(cmCTestBuildCommand, cmCTestCommand);
 
-  cmGlobalGenerator* m_GlobalGenerator;
+  cmGlobalGenerator* GlobalGenerator;
 };
 
 
diff --git a/Source/CTest/cmCTestBuildHandler.cxx b/Source/CTest/cmCTestBuildHandler.cxx
index a5f9143..d00b738 100644
--- a/Source/CTest/cmCTestBuildHandler.cxx
+++ b/Source/CTest/cmCTestBuildHandler.cxx
@@ -146,9 +146,9 @@ static const char* cmCTestWarningExceptions[] = {
 
 struct cmCTestBuildCompileErrorWarningRex
 {
-  const char* m_RegularExpressionString;
-  int m_FileIndex;
-  int m_LineIndex;
+  const char* RegularExpressionString;
+  int FileIndex;
+  int LineIndex;
 };
 
 static cmCTestBuildCompileErrorWarningRex
@@ -165,13 +165,13 @@ cmCTestWarningErrorFileLine[] = {
 //----------------------------------------------------------------------
 cmCTestBuildHandler::cmCTestBuildHandler()
 {
-  m_MaxPreContext = 6;
-  m_MaxPostContext = 6;
+  this->MaxPreContext = 6;
+  this->MaxPostContext = 6;
 
-  m_MaxErrors = 50;
-  m_MaxWarnings = 50;
+  this->MaxErrors = 50;
+  this->MaxWarnings = 50;
 
-  m_LastErrorOrWarning = m_ErrorsAndWarnings.end();
+  this->LastErrorOrWarning = this->ErrorsAndWarnings.end();
 
 }
 
@@ -179,61 +179,61 @@ cmCTestBuildHandler::cmCTestBuildHandler()
 void cmCTestBuildHandler::Initialize()
 {
   this->Superclass::Initialize();
-  m_StartBuild = "";
-  m_EndBuild = "";
-  m_CustomErrorMatches.clear();
-  m_CustomErrorExceptions.clear();
-  m_CustomWarningMatches.clear();
-  m_CustomWarningExceptions.clear();
-  m_ErrorWarningFileLineRegex.clear();
-
-  m_ErrorMatchRegex.clear();
-  m_ErrorExceptionRegex.clear();
-  m_WarningMatchRegex.clear();
-  m_WarningExceptionRegex.clear();
-  m_BuildProcessingQueue.clear();
-  m_BuildProcessingErrorQueue.clear();
-  m_BuildOutputLogSize = 0;
-  m_CurrentProcessingLine.clear();
-
-  m_SimplifySourceDir = "";
-  m_SimplifyBuildDir = "";
-  m_OutputLineCounter = 0;
-  m_ErrorsAndWarnings.clear();
-  m_LastErrorOrWarning = m_ErrorsAndWarnings.end();
-  m_PostContextCount = 0;
-  m_MaxPreContext = 6;
-  m_MaxPostContext = 6;
-  m_PreContext.clear();
-
-  m_TotalErrors = 0;
-  m_TotalWarnings = 0;
-  m_LastTickChar = 0;
-
-  m_ErrorQuotaReached = false;
-  m_WarningQuotaReached = false;
-
-  m_MaxErrors = 50;
-  m_MaxWarnings = 50;
+  this->StartBuild = "";
+  this->EndBuild = "";
+  this->CustomErrorMatches.clear();
+  this->CustomErrorExceptions.clear();
+  this->CustomWarningMatches.clear();
+  this->CustomWarningExceptions.clear();
+  this->ErrorWarningFileLineRegex.clear();
+
+  this->ErrorMatchRegex.clear();
+  this->ErrorExceptionRegex.clear();
+  this->WarningMatchRegex.clear();
+  this->WarningExceptionRegex.clear();
+  this->BuildProcessingQueue.clear();
+  this->BuildProcessingErrorQueue.clear();
+  this->BuildOutputLogSize = 0;
+  this->CurrentProcessingLine.clear();
+
+  this->SimplifySourceDir = "";
+  this->SimplifyBuildDir = "";
+  this->OutputLineCounter = 0;
+  this->ErrorsAndWarnings.clear();
+  this->LastErrorOrWarning = this->ErrorsAndWarnings.end();
+  this->PostContextCount = 0;
+  this->MaxPreContext = 6;
+  this->MaxPostContext = 6;
+  this->PreContext.clear();
+
+  this->TotalErrors = 0;
+  this->TotalWarnings = 0;
+  this->LastTickChar = 0;
+
+  this->ErrorQuotaReached = false;
+  this->WarningQuotaReached = false;
+
+  this->MaxErrors = 50;
+  this->MaxWarnings = 50;
 }
 
 //----------------------------------------------------------------------
 void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile *mf)
 {
   cmCTest::PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_MATCH",
-                                m_CustomErrorMatches);
+                                this->CustomErrorMatches);
   cmCTest::PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_EXCEPTION",
-                                m_CustomErrorExceptions);
+                                this->CustomErrorExceptions);
   cmCTest::PopulateCustomVector(mf, "CTEST_CUSTOM_WARNING_MATCH",
-                                m_CustomWarningMatches);
+                                this->CustomWarningMatches);
   cmCTest::PopulateCustomVector(mf, "CTEST_CUSTOM_WARNING_EXCEPTION",
-                                m_CustomWarningExceptions);
+                                this->CustomWarningExceptions);
   cmCTest::PopulateCustomInteger(mf,
                              "CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS",
-                             m_MaxErrors);
+                             this->MaxErrors);
   cmCTest::PopulateCustomInteger(mf,
                              "CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS",
-                             m_MaxWarnings);
+                             this->MaxWarnings);
 }
 
 //----------------------------------------------------------------------
@@ -241,45 +241,45 @@ void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile *mf)
 //functions and commented...
 int cmCTestBuildHandler::ProcessHandler()
 {
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "Build project" << std::endl);
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "Build project" << std::endl);
 
   int entry;
   for ( entry = 0;
-    cmCTestWarningErrorFileLine[entry].m_RegularExpressionString;
+    cmCTestWarningErrorFileLine[entry].RegularExpressionString;
     ++ entry )
     {
     cmCTestBuildHandler::cmCTestCompileErrorWarningRex r;
-    if ( r.m_RegularExpression.compile(
-        cmCTestWarningErrorFileLine[entry].m_RegularExpressionString) )
+    if ( r.RegularExpression.compile(
+        cmCTestWarningErrorFileLine[entry].RegularExpressionString) )
       {
-      r.m_FileIndex = cmCTestWarningErrorFileLine[entry].m_FileIndex;
-      r.m_LineIndex = cmCTestWarningErrorFileLine[entry].m_LineIndex;
-      m_ErrorWarningFileLineRegex.push_back(r);
+      r.FileIndex = cmCTestWarningErrorFileLine[entry].FileIndex;
+      r.LineIndex = cmCTestWarningErrorFileLine[entry].LineIndex;
+      this->ErrorWarningFileLineRegex.push_back(r);
       }
     else
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE,
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
         "Problem Compiling regular expression: "
-       << cmCTestWarningErrorFileLine[entry].m_RegularExpressionString
+       << cmCTestWarningErrorFileLine[entry].RegularExpressionString
        << std::endl);
       }
     }
 
   // Determine build command and build directory
   const std::string &makeCommand
-    = m_CTest->GetCTestConfiguration("MakeCommand");
+    = this->CTest->GetCTestConfiguration("MakeCommand");
   if ( makeCommand.size() == 0 )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE,
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
       "Cannot find MakeCommand key in the DartConfiguration.tcl"
       << std::endl);
     return -1;
     }
   const std::string &buildDirectory
-    = m_CTest->GetCTestConfiguration("BuildDirectory");
+    = this->CTest->GetCTestConfiguration("BuildDirectory");
   if ( buildDirectory.size() == 0 )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE,
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
       "Cannot find BuildDirectory  key in the DartConfiguration.tcl"
       << std::endl);
     return -1;
@@ -290,7 +290,7 @@ int cmCTestBuildHandler::ProcessHandler()
   double elapsed_time_start = cmSystemTools::GetTime();
   if ( !this->StartLogFile("Build", ofs) )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create build log file"
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create build log file"
       << std::endl);
     }
 
@@ -299,19 +299,19 @@ int cmCTestBuildHandler::ProcessHandler()
   std::vector<cmStdString>::size_type cc;
   for ( cc = 0; cmCTestErrorMatches[cc]; cc ++ )
     {
-    m_CustomErrorMatches.push_back(cmCTestErrorMatches[cc]);
+    this->CustomErrorMatches.push_back(cmCTestErrorMatches[cc]);
     }
   for ( cc = 0; cmCTestErrorExceptions[cc]; cc ++ )
     {
-    m_CustomErrorExceptions.push_back(cmCTestErrorExceptions[cc]);
+    this->CustomErrorExceptions.push_back(cmCTestErrorExceptions[cc]);
     }
   for ( cc = 0; cmCTestWarningMatches[cc]; cc ++ )
     {
-    m_CustomWarningMatches.push_back(cmCTestWarningMatches[cc]);
+    this->CustomWarningMatches.push_back(cmCTestWarningMatches[cc]);
     }
   for ( cc = 0; cmCTestWarningExceptions[cc]; cc ++ )
     {
-    m_CustomWarningExceptions.push_back(cmCTestWarningExceptions[cc]);
+    this->CustomWarningExceptions.push_back(cmCTestWarningExceptions[cc]);
     }
 
   // Pre-compile regular expressions objects for all regular expressions
@@ -324,22 +324,22 @@ int cmCTestBuildHandler::ProcessHandler()
     regexes.push_back(it->c_str()); \
     }
   cmCTestBuildHandlerPopulateRegexVector(
-    m_CustomErrorMatches, m_ErrorMatchRegex);
+    this->CustomErrorMatches, this->ErrorMatchRegex);
   cmCTestBuildHandlerPopulateRegexVector(
-    m_CustomErrorExceptions, m_ErrorExceptionRegex);
+    this->CustomErrorExceptions, this->ErrorExceptionRegex);
   cmCTestBuildHandlerPopulateRegexVector(
-    m_CustomWarningMatches, m_WarningMatchRegex);
+    this->CustomWarningMatches, this->WarningMatchRegex);
   cmCTestBuildHandlerPopulateRegexVector(
-    m_CustomWarningExceptions, m_WarningExceptionRegex);
+    this->CustomWarningExceptions, this->WarningExceptionRegex);
 
 
   // Determine source and binary tree substitutions to simplify the output.
-  m_SimplifySourceDir = "";
-  m_SimplifyBuildDir = "";
-  if ( m_CTest->GetCTestConfiguration("SourceDirectory").size() > 20 )
+  this->SimplifySourceDir = "";
+  this->SimplifyBuildDir = "";
+  if ( this->CTest->GetCTestConfiguration("SourceDirectory").size() > 20 )
     {
     std::string srcdir
-      = m_CTest->GetCTestConfiguration("SourceDirectory") + "/";
+      = this->CTest->GetCTestConfiguration("SourceDirectory") + "/";
     std::string srcdirrep;
     for ( cc = srcdir.size()-2; cc > 0; cc -- )
       {
@@ -351,12 +351,12 @@ int cmCTestBuildHandler::ProcessHandler()
         break;
         }
       }
-    m_SimplifySourceDir = srcdir;
+    this->SimplifySourceDir = srcdir;
     }
-  if ( m_CTest->GetCTestConfiguration("BuildDirectory").size() > 20 )
+  if ( this->CTest->GetCTestConfiguration("BuildDirectory").size() > 20 )
     {
     std::string bindir
-      = m_CTest->GetCTestConfiguration("BuildDirectory") + "/";
+      = this->CTest->GetCTestConfiguration("BuildDirectory") + "/";
     std::string bindirrep;
     for ( cc = bindir.size()-2; cc > 0; cc -- )
       {
@@ -368,86 +368,86 @@ int cmCTestBuildHandler::ProcessHandler()
         break;
         }
       }
-    m_SimplifyBuildDir = bindir;
+    this->SimplifyBuildDir = bindir;
     }
 
 
   // Ok, let's do the build
 
   // Remember start build time
-  m_StartBuild = m_CTest->CurrentTime();
+  this->StartBuild = this->CTest->CurrentTime();
   int retVal = 0;
   int res = cmsysProcess_State_Exited;
-  if ( !m_CTest->GetShowOnly() )
+  if ( !this->CTest->GetShowOnly() )
     {
     res = this->RunMakeCommand(makeCommand.c_str(), &retVal,
       buildDirectory.c_str(), 0, ofs);
     }
   else
     {
-    cmCTestLog(m_CTest, DEBUG, "Build with command: " << makeCommand
+    cmCTestLog(this->CTest, DEBUG, "Build with command: " << makeCommand
       << std::endl);
     }
 
   // Remember end build time and calculate elapsed time
-  m_EndBuild = m_CTest->CurrentTime();
+  this->EndBuild = this->CTest->CurrentTime();
   double elapsed_build_time = cmSystemTools::GetTime() - elapsed_time_start;
   if (res != cmsysProcess_State_Exited || retVal )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Error(s) when building project"
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error(s) when building project"
       << std::endl);
     }
 
   // Cleanups strings in the errors and warnings list.
   t_ErrorsAndWarningsVector::iterator evit;
-  if ( !m_SimplifySourceDir.empty() )
+  if ( !this->SimplifySourceDir.empty() )
     {
-    for ( evit = m_ErrorsAndWarnings.begin();
-      evit != m_ErrorsAndWarnings.end();
+    for ( evit = this->ErrorsAndWarnings.begin();
+      evit != this->ErrorsAndWarnings.end();
       ++ evit )
       {
       cmSystemTools::ReplaceString(
-        evit->m_Text, m_SimplifySourceDir.c_str(), "/.../");
+        evit->Text, this->SimplifySourceDir.c_str(), "/.../");
       cmSystemTools::ReplaceString(
-        evit->m_PreContext, m_SimplifySourceDir.c_str(), "/.../");
+        evit->PreContext, this->SimplifySourceDir.c_str(), "/.../");
       cmSystemTools::ReplaceString(
-        evit->m_PostContext, m_SimplifySourceDir.c_str(), "/.../");
+        evit->PostContext, this->SimplifySourceDir.c_str(), "/.../");
       }
     }
 
-  if ( !m_SimplifyBuildDir.empty() )
+  if ( !this->SimplifyBuildDir.empty() )
     {
-    for ( evit = m_ErrorsAndWarnings.begin();
-      evit != m_ErrorsAndWarnings.end();
+    for ( evit = this->ErrorsAndWarnings.begin();
+      evit != this->ErrorsAndWarnings.end();
       ++ evit )
       {
       cmSystemTools::ReplaceString(
-        evit->m_Text, m_SimplifyBuildDir.c_str(), "/.../");
+        evit->Text, this->SimplifyBuildDir.c_str(), "/.../");
       cmSystemTools::ReplaceString(
-        evit->m_PreContext, m_SimplifyBuildDir.c_str(), "/.../");
+        evit->PreContext, this->SimplifyBuildDir.c_str(), "/.../");
       cmSystemTools::ReplaceString(
-        evit->m_PostContext, m_SimplifyBuildDir.c_str(), "/.../");
+        evit->PostContext, this->SimplifyBuildDir.c_str(), "/.../");
       }
     }
 
   // Display message about number of errors and warnings
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "   " << m_TotalErrors
-    << (m_TotalErrors >= m_MaxErrors ? " or more" : "")
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   " << this->TotalErrors
+    << (this->TotalErrors >= this->MaxErrors ? " or more" : "")
     << " Compiler errors" << std::endl);
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "   " << m_TotalWarnings
-    << (m_TotalWarnings >= m_MaxWarnings ? " or more" : "")
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   " << this->TotalWarnings
+    << (this->TotalWarnings >= this->MaxWarnings ? " or more" : "")
     << " Compiler warnings" << std::endl);
 
   // Generate XML output
   cmGeneratedFileStream xofs;
   if( !this->StartResultingXML("Build", xofs))
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create build XML file"
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create build XML file"
       << std::endl);
     return -1;
     }
   this->GenerateDartBuildOutput(
-    xofs, m_ErrorsAndWarnings, elapsed_build_time);
+    xofs, this->ErrorsAndWarnings, elapsed_build_time);
   return 0;
 }
 
@@ -457,19 +457,20 @@ void cmCTestBuildHandler::GenerateDartBuildOutput(
   std::vector<cmCTestBuildErrorWarning> ew,
   double elapsed_build_time)
 {
-  m_CTest->StartXML(os);
+  this->CTest->StartXML(os);
   os << "<Build>\n"
-     << "\t<StartDateTime>" << m_StartBuild << "</StartDateTime>\n"
+     << "\t<StartDateTime>" << this->StartBuild << "</StartDateTime>\n"
      << "<BuildCommand>"
-     << m_CTest->MakeXMLSafe(m_CTest->GetCTestConfiguration("MakeCommand"))
+     << this->CTest->MakeXMLSafe(
+       this->CTest->GetCTestConfiguration("MakeCommand"))
      << "</BuildCommand>" << std::endl;
 
   std::vector<cmCTestBuildErrorWarning>::iterator it;
 
   // only report the first 50 warnings and first 50 errors
-  unsigned short numErrorsAllowed = m_MaxErrors;
-  unsigned short numWarningsAllowed = m_MaxWarnings;
-  std::string srcdir = m_CTest->GetCTestConfiguration("SourceDirectory");
+  unsigned short numErrorsAllowed = this->MaxErrors;
+  unsigned short numWarningsAllowed = this->MaxWarnings;
+  std::string srcdir = this->CTest->GetCTestConfiguration("SourceDirectory");
   // make sure the source dir is in the correct case on windows
   // via a call to collapse full path.
   srcdir = cmSystemTools::CollapseFullPath(srcdir.c_str());
@@ -478,10 +479,10 @@ void cmCTestBuildHandler::GenerateDartBuildOutput(
         it != ew.end() && (numErrorsAllowed || numWarningsAllowed); it++ )
     {
     cmCTestBuildErrorWarning *cm = &(*it);
-    if (cm->m_Error && numErrorsAllowed ||
-        !cm->m_Error && numWarningsAllowed)
+    if (cm->Error && numErrorsAllowed ||
+        !cm->Error && numWarningsAllowed)
       {
-      if (cm->m_Error)
+      if (cm->Error)
         {
         numErrorsAllowed--;
         }
@@ -489,80 +490,80 @@ void cmCTestBuildHandler::GenerateDartBuildOutput(
         {
         numWarningsAllowed--;
         }
-      os << "\t<" << (cm->m_Error ? "Error" : "Warning") << ">\n"
-         << "\t\t<BuildLogLine>" << cm->m_LogLine << "</BuildLogLine>\n"
-         << "\t\t<Text>" << m_CTest->MakeXMLSafe(cm->m_Text)
+      os << "\t<" << (cm->Error ? "Error" : "Warning") << ">\n"
+         << "\t\t<BuildLogLine>" << cm->LogLine << "</BuildLogLine>\n"
+         << "\t\t<Text>" << this->CTest->MakeXMLSafe(cm->Text)
          << "\n</Text>" << std::endl;
       std::vector<cmCTestCompileErrorWarningRex>::iterator rit;
-      for ( rit = m_ErrorWarningFileLineRegex.begin();
-            rit != m_ErrorWarningFileLineRegex.end(); ++ rit )
+      for ( rit = this->ErrorWarningFileLineRegex.begin();
+            rit != this->ErrorWarningFileLineRegex.end(); ++ rit )
         {
-        cmsys::RegularExpression* re = &rit->m_RegularExpression;
-        if ( re->find(cm->m_Text.c_str() ) )
+        cmsys::RegularExpression* re = &rit->RegularExpression;
+        if ( re->find(cm->Text.c_str() ) )
           {
-          cm->m_SourceFile = re->match(rit->m_FileIndex);
-          // At this point we need to make m_SourceFile relative to
+          cm->SourceFile = re->match(rit->FileIndex);
+          // At this point we need to make this->SourceFile relative to
           // the source root of the project, so cvs links will work
-          cmSystemTools::ConvertToUnixSlashes(cm->m_SourceFile);
-          if(cm->m_SourceFile.find("/.../") != cm->m_SourceFile.npos)
+          cmSystemTools::ConvertToUnixSlashes(cm->SourceFile);
+          if(cm->SourceFile.find("/.../") != cm->SourceFile.npos)
             {
-            cmSystemTools::ReplaceString(cm->m_SourceFile, "/.../", "");
-            std::string::size_type p = cm->m_SourceFile.find("/");
-            if(p != cm->m_SourceFile.npos)
+            cmSystemTools::ReplaceString(cm->SourceFile, "/.../", "");
+            std::string::size_type p = cm->SourceFile.find("/");
+            if(p != cm->SourceFile.npos)
               {
-              cm->m_SourceFile = cm->m_SourceFile.substr(
-                p+1, cm->m_SourceFile.size()-p);
+              cm->SourceFile = cm->SourceFile.substr(
+                p+1, cm->SourceFile.size()-p);
               }
             }
           else
             {
             // make sure it is a full path with the correct case
-            cm->m_SourceFile = cmSystemTools::CollapseFullPath(
-              cm->m_SourceFile.c_str());
+            cm->SourceFile = cmSystemTools::CollapseFullPath(
+              cm->SourceFile.c_str());
             cmSystemTools::ReplaceString(
-              cm->m_SourceFile, srcdir.c_str(), "");
+              cm->SourceFile, srcdir.c_str(), "");
             }
-          cm->m_LineNumber = atoi(re->match(rit->m_LineIndex).c_str());
+          cm->LineNumber = atoi(re->match(rit->LineIndex).c_str());
           break;
           }
         }
-      if ( cm->m_SourceFile.size() > 0 )
+      if ( cm->SourceFile.size() > 0 )
         {
-        os << "\t\t<SourceFile>" << cm->m_SourceFile << "</SourceFile>"
+        os << "\t\t<SourceFile>" << cm->SourceFile << "</SourceFile>"
            << std::endl;
         }
-      if ( cm->m_SourceFileTail.size() > 0 )
+      if ( cm->SourceFileTail.size() > 0 )
         {
-        os << "\t\t<SourceFileTail>" << cm->m_SourceFileTail
+        os << "\t\t<SourceFileTail>" << cm->SourceFileTail
            << "</SourceFileTail>" << std::endl;
         }
-      if ( cm->m_LineNumber >= 0 )
+      if ( cm->LineNumber >= 0 )
         {
-        os << "\t\t<SourceLineNumber>" << cm->m_LineNumber
+        os << "\t\t<SourceLineNumber>" << cm->LineNumber
            << "</SourceLineNumber>" << std::endl;
         }
-      os << "\t\t<PreContext>" << m_CTest->MakeXMLSafe(cm->m_PreContext)
+      os << "\t\t<PreContext>" << this->CTest->MakeXMLSafe(cm->PreContext)
          << "</PreContext>\n"
-         << "\t\t<PostContext>" << m_CTest->MakeXMLSafe(cm->m_PostContext);
+         << "\t\t<PostContext>" << this->CTest->MakeXMLSafe(cm->PostContext);
       // is this the last warning or error, if so notify
-      if (cm->m_Error && !numErrorsAllowed ||
-          !cm->m_Error && !numWarningsAllowed)
+      if (cm->Error && !numErrorsAllowed ||
+          !cm->Error && !numWarningsAllowed)
         {
         os << "\nThe maximum number of reported warnings or errors has been "
           "reached!!!\n";
         }
       os << "</PostContext>\n"
          << "\t\t<RepeatCount>0</RepeatCount>\n"
-         << "</" << (cm->m_Error ? "Error" : "Warning") << ">\n\n"
+         << "</" << (cm->Error ? "Error" : "Warning") << ">\n\n"
          << std::endl;
       }
     }
   os << "\t<Log Encoding=\"base64\" Compression=\"/bin/gzip\">\n\t</Log>\n"
-     << "\t<EndDateTime>" << m_EndBuild << "</EndDateTime>\n"
+     << "\t<EndDateTime>" << this->EndBuild << "</EndDateTime>\n"
      << "<ElapsedMinutes>" << static_cast<int>(elapsed_build_time/6)/10.0
      << "</ElapsedMinutes>"
      << "</Build>" << std::endl;
-  m_CTest->EndXML(os);
+  this->CTest->EndXML(os);
 }
 
 //######################################################################
@@ -590,13 +591,13 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command,
     }
   argv.push_back(0);
 
-  cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Run command:");
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command:");
   std::vector<const char*>::iterator ait;
   for ( ait = argv.begin(); ait != argv.end() && *ait; ++ ait )
     {
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " \"" << *ait << "\"");
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, " \"" << *ait << "\"");
     }
-  cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, std::endl);
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl);
 
   // Now create process object
   cmsysProcess* cp = cmsysProcess_New();
@@ -612,22 +613,22 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command,
 
   char* data;
   int length;
-  cmCTestLog(m_CTest, HANDLER_OUTPUT,
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
     "   Each symbol represents " << tick_len << " bytes of output."
     << std::endl
     << "   '!' represents an error and '*' a warning." << std::endl
     << "    " << std::flush);
 
   // Initialize building structures
-  m_BuildProcessingQueue.clear();
-  m_OutputLineCounter = 0;
-  m_ErrorsAndWarnings.clear();
-  m_TotalErrors = 0;
-  m_TotalWarnings = 0;
-  m_BuildOutputLogSize = 0;
-  m_LastTickChar = '.';
-  m_WarningQuotaReached = false;
-  m_ErrorQuotaReached = false;
+  this->BuildProcessingQueue.clear();
+  this->OutputLineCounter = 0;
+  this->ErrorsAndWarnings.clear();
+  this->TotalErrors = 0;
+  this->TotalWarnings = 0;
+  this->BuildOutputLogSize = 0;
+  this->LastTickChar = '.';
+  this->WarningQuotaReached = false;
+  this->ErrorQuotaReached = false;
 
   // For every chunk of data
   int res;
@@ -647,20 +648,20 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command,
     if ( res == cmsysProcess_Pipe_STDERR )
       {
       this->ProcessBuffer(data, length, tick, tick_len, ofs,
-        &m_BuildProcessingErrorQueue);
+        &this->BuildProcessingErrorQueue);
       }
     else
       {
       this->ProcessBuffer(data, length, tick, tick_len, ofs,
-        &m_BuildProcessingQueue);
+        &this->BuildProcessingQueue);
       }
     }
 
-  this->ProcessBuffer(0, 0, tick, tick_len, ofs, &m_BuildProcessingQueue);
+  this->ProcessBuffer(0, 0, tick, tick_len, ofs, &this->BuildProcessingQueue);
   this->ProcessBuffer(0, 0, tick, tick_len, ofs,
-    &m_BuildProcessingErrorQueue);
-  cmCTestLog(m_CTest, OUTPUT, " Size of output: "
-    << int(m_BuildOutputLogSize / 1024.0) << "K" << std::endl);
+    &this->BuildProcessingErrorQueue);
+  cmCTestLog(this->CTest, OUTPUT, " Size of output: "
+    << int(this->BuildOutputLogSize / 1024.0) << "K" << std::endl);
 
   // Properly handle output of the build command
   cmsysProcess_WaitForExit(cp, 0);
@@ -669,32 +670,32 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command,
   if(result == cmsysProcess_State_Exited)
     {
     *retVal = cmsysProcess_GetExitValue(cp);
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT,
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
       "Command exited with the value: " << *retVal << std::endl);
     }
   else if(result == cmsysProcess_State_Exception)
     {
     *retVal = cmsysProcess_GetExitException(cp);
-    cmCTestLog(m_CTest, WARNING, "There was an exception: " << *retVal
+    cmCTestLog(this->CTest, WARNING, "There was an exception: " << *retVal
       << std::endl);
     }
   else if(result == cmsysProcess_State_Expired)
     {
-    cmCTestLog(m_CTest, WARNING, "There was a timeout" << std::endl);
+    cmCTestLog(this->CTest, WARNING, "There was a timeout" << std::endl);
     }
   else if(result == cmsysProcess_State_Error)
     {
     // If there was an error running command, report that on the dashboard.
     cmCTestBuildErrorWarning errorwarning;
-    errorwarning.m_LogLine     = 1;
-    errorwarning.m_Text        = "*** ERROR executing: ";
-    errorwarning.m_Text        += cmsysProcess_GetErrorString(cp);
-    errorwarning.m_PreContext  = "";
-    errorwarning.m_PostContext = "";
-    errorwarning.m_Error       = true;
-    m_ErrorsAndWarnings.push_back(errorwarning);
-    m_TotalErrors ++;
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "There was an error: "
+    errorwarning.LogLine     = 1;
+    errorwarning.Text        = "*** ERROR executing: ";
+    errorwarning.Text        += cmsysProcess_GetErrorString(cp);
+    errorwarning.PreContext  = "";
+    errorwarning.PostContext = "";
+    errorwarning.Error       = true;
+    this->ErrorsAndWarnings.push_back(errorwarning);
+    this->TotalErrors ++;
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "There was an error: "
       << cmsysProcess_GetErrorString(cp) << std::endl);
     }
 
@@ -720,7 +721,7 @@ void cmCTestBuildHandler::ProcessBuffer(const char* data, int length,
     {
     queue->push_back(*ptr);
     }
-  m_BuildOutputLogSize += length;
+  this->BuildOutputLogSize += length;
 
   // until there are any lines left in the buffer
   while ( 1 )
@@ -739,27 +740,27 @@ void cmCTestBuildHandler::ProcessBuffer(const char* data, int length,
 
     // Once certain number of errors or warnings reached, ignore future errors
     // or warnings.
-    if ( m_TotalWarnings >= m_MaxWarnings )
+    if ( this->TotalWarnings >= this->MaxWarnings )
       {
-      m_WarningQuotaReached = true;
+      this->WarningQuotaReached = true;
       }
-    if ( m_TotalErrors >= m_MaxErrors )
+    if ( this->TotalErrors >= this->MaxErrors )
       {
-      m_ErrorQuotaReached = true;
+      this->ErrorQuotaReached = true;
       }
 
     // If the end of line was found
     if ( it != queue->end() )
       {
       // Create a contiguous array for the line
-      m_CurrentProcessingLine.clear();
+      this->CurrentProcessingLine.clear();
       t_BuildProcessingQueueType::iterator cit;
       for ( cit = queue->begin(); cit != it; ++cit )
         {
-        m_CurrentProcessingLine.push_back(*cit);
+        this->CurrentProcessingLine.push_back(*cit);
         }
-      m_CurrentProcessingLine.push_back(0);
-      const char* line = &*m_CurrentProcessingLine.begin();
+      this->CurrentProcessingLine.push_back(0);
+      const char* line = &*this->CurrentProcessingLine.begin();
 
       // Process the line
       int lineType = this->ProcessSingleLine(line);
@@ -773,67 +774,67 @@ void cmCTestBuildHandler::ProcessBuffer(const char* data, int length,
       switch ( lineType )
         {
       case b_WARNING_LINE:
-        m_LastTickChar = '*';
-        errorwarning.m_Error = false;
+        this->LastTickChar = '*';
+        errorwarning.Error = false;
         found = true;
-        m_TotalWarnings ++;
+        this->TotalWarnings ++;
         break;
       case b_ERROR_LINE:
-        m_LastTickChar = '!';
-        errorwarning.m_Error = true;
+        this->LastTickChar = '!';
+        errorwarning.Error = true;
         found = true;
-        m_TotalErrors ++;
+        this->TotalErrors ++;
         break;
         }
       if ( found )
         {
         // This is an error or warning, so generate report
-        errorwarning.m_LogLine     = static_cast<int>(m_OutputLineCounter+1);
-        errorwarning.m_Text        = line;
-        errorwarning.m_PreContext  = "";
-        errorwarning.m_PostContext = "";
+        errorwarning.LogLine   = static_cast<int>(this->OutputLineCounter+1);
+        errorwarning.Text        = line;
+        errorwarning.PreContext  = "";
+        errorwarning.PostContext = "";
 
         // Copy pre-context to report
         std::deque<cmStdString>::iterator pcit;
-        for ( pcit = m_PreContext.begin();
-          pcit != m_PreContext.end();
+        for ( pcit = this->PreContext.begin();
+          pcit != this->PreContext.end();
           ++pcit )
           {
-          errorwarning.m_PreContext += *pcit + "\n";
+          errorwarning.PreContext += *pcit + "\n";
           }
-        m_PreContext.clear();
+        this->PreContext.clear();
 
         // Store report
-        m_ErrorsAndWarnings.push_back(errorwarning);
-        m_LastErrorOrWarning = m_ErrorsAndWarnings.end()-1;
-        m_PostContextCount = 0;
+        this->ErrorsAndWarnings.push_back(errorwarning);
+        this->LastErrorOrWarning = this->ErrorsAndWarnings.end()-1;
+        this->PostContextCount = 0;
         }
       else
         {
         // This is not an error or warning.
         // So, figure out if this is a post-context line
-        if ( m_LastErrorOrWarning != m_ErrorsAndWarnings.end() &&
-          m_PostContextCount < m_MaxPostContext )
+        if ( this->LastErrorOrWarning != this->ErrorsAndWarnings.end() &&
+          this->PostContextCount < this->MaxPostContext )
           {
-          m_PostContextCount ++;
-          m_LastErrorOrWarning->m_PostContext += line;
-          if ( m_PostContextCount < m_MaxPostContext )
+          this->PostContextCount ++;
+          this->LastErrorOrWarning->PostContext += line;
+          if ( this->PostContextCount < this->MaxPostContext )
             {
-            m_LastErrorOrWarning->m_PostContext += "\n";
+            this->LastErrorOrWarning->PostContext += "\n";
             }
           }
         else
           {
           // Otherwise store pre-context for the next error
-          m_PreContext.push_back(line);
-          if ( m_PreContext.size() > m_MaxPreContext )
+          this->PreContext.push_back(line);
+          if ( this->PreContext.size() > this->MaxPreContext )
             {
-            m_PreContext.erase(m_PreContext.begin(),
-              m_PreContext.end()-m_MaxPreContext);
+            this->PreContext.erase(this->PreContext.begin(),
+              this->PreContext.end()-this->MaxPreContext);
             }
           }
         }
-      m_OutputLineCounter ++;
+      this->OutputLineCounter ++;
       }
     else
       {
@@ -843,25 +844,26 @@ void cmCTestBuildHandler::ProcessBuffer(const char* data, int length,
 
   // Now that the buffer is processed, display missing ticks
   int tickDisplayed = false;
-  while ( m_BuildOutputLogSize > (tick * tick_len) )
+  while ( this->BuildOutputLogSize > (tick * tick_len) )
     {
     tick ++;
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, m_LastTickChar);
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, this->LastTickChar);
     tickDisplayed = true;
     if ( tick % tick_line_len == 0 && tick > 0 )
       {
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, "  Size: "
-        << int((m_BuildOutputLogSize / 1024.0) + 1) << "K" << std::endl
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "  Size: "
+        << int((this->BuildOutputLogSize / 1024.0) + 1) << "K" << std::endl
         << "    ");
       }
     }
   if ( tickDisplayed )
     {
-    m_LastTickChar = '.';
+    this->LastTickChar = '.';
     }
 
   // And if this is verbose output, display the content of the chunk
-  cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, cmCTestLogWrite(data, length));
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+    cmCTestLogWrite(data, length));
 
   // Always store the chunk to the file
   ofs << cmCTestLogWrite(data, length);
@@ -870,7 +872,7 @@ void cmCTestBuildHandler::ProcessBuffer(const char* data, int length,
 //----------------------------------------------------------------------
 int cmCTestBuildHandler::ProcessSingleLine(const char* data)
 {
-  cmCTestLog(m_CTest, DEBUG, "Line: [" << data << "]" << std::endl);
+  cmCTestLog(this->CTest, DEBUG, "Line: [" << data << "]" << std::endl);
 
   std::vector<cmsys::RegularExpression>::iterator it;
 
@@ -879,58 +881,59 @@ int cmCTestBuildHandler::ProcessSingleLine(const char* data)
 
   // Check for regular expressions
 
-  if ( !m_ErrorQuotaReached )
+  if ( !this->ErrorQuotaReached )
     {
     // Errors
-    for ( it = m_ErrorMatchRegex.begin();
-      it != m_ErrorMatchRegex.end();
+    for ( it = this->ErrorMatchRegex.begin();
+      it != this->ErrorMatchRegex.end();
       ++ it )
       {
       if ( it->find(data) )
         {
         errorLine = 1;
-        cmCTestLog(m_CTest, DEBUG, "  Error Line: " << data << std::endl);
+        cmCTestLog(this->CTest, DEBUG, "  Error Line: " << data << std::endl);
         break;
         }
       }
     // Error exceptions
-    for ( it = m_ErrorExceptionRegex.begin();
-      it != m_ErrorExceptionRegex.end();
+    for ( it = this->ErrorExceptionRegex.begin();
+      it != this->ErrorExceptionRegex.end();
       ++ it )
       {
       if ( it->find(data) )
         {
         errorLine = 0;
-        cmCTestLog(m_CTest, DEBUG, "  Not an error Line: " << data
+        cmCTestLog(this->CTest, DEBUG, "  Not an error Line: " << data
           << std::endl);
         break;
         }
       }
     }
-  if ( !m_WarningQuotaReached )
+  if ( !this->WarningQuotaReached )
     {
     // Warnings
-    for ( it = m_WarningMatchRegex.begin();
-      it != m_WarningMatchRegex.end();
+    for ( it = this->WarningMatchRegex.begin();
+      it != this->WarningMatchRegex.end();
       ++ it )
       {
       if ( it->find(data) )
         {
         warningLine = 1;
-        cmCTestLog(m_CTest, DEBUG, "  Warning Line: " << data << std::endl);
+        cmCTestLog(this->CTest, DEBUG,
+          "  Warning Line: " << data << std::endl);
         break;
         }
       }
 
     // Warning exceptions
-    for ( it = m_WarningExceptionRegex.begin();
-      it != m_WarningExceptionRegex.end();
+    for ( it = this->WarningExceptionRegex.begin();
+      it != this->WarningExceptionRegex.end();
       ++ it )
       {
       if ( it->find(data) )
         {
         warningLine = 0;
-        cmCTestLog(m_CTest, DEBUG, "  Not a warning Line: " << data
+        cmCTestLog(this->CTest, DEBUG, "  Not a warning Line: " << data
           << std::endl);
         break;
         }
diff --git a/Source/CTest/cmCTestBuildHandler.h b/Source/CTest/cmCTestBuildHandler.h
index 1750452..e4f3f43 100644
--- a/Source/CTest/cmCTestBuildHandler.h
+++ b/Source/CTest/cmCTestBuildHandler.h
@@ -66,21 +66,21 @@ private:
     {
   public:
     cmCTestCompileErrorWarningRex() {}
-    int m_FileIndex;
-    int m_LineIndex;
-    cmsys::RegularExpression m_RegularExpression;
+    int FileIndex;
+    int LineIndex;
+    cmsys::RegularExpression RegularExpression;
     };
 
   struct cmCTestBuildErrorWarning
   {
-    bool        m_Error;
-    int         m_LogLine;
-    std::string m_Text;
-    std::string m_SourceFile;
-    std::string m_SourceFileTail;
-    int         m_LineNumber;
-    std::string m_PreContext;
-    std::string m_PostContext;
+    bool        Error;
+    int         LogLine;
+    std::string Text;
+    std::string SourceFile;
+    std::string SourceFileTail;
+    int         LineNumber;
+    std::string PreContext;
+    std::string PostContext;
   };
 
   // generate the XML output
@@ -89,19 +89,19 @@ private:
                                double elapsed_time);
 
 
-  std::string             m_StartBuild;
-  std::string             m_EndBuild;
+  std::string             StartBuild;
+  std::string             EndBuild;
 
-  std::vector<cmStdString> m_CustomErrorMatches;
-  std::vector<cmStdString> m_CustomErrorExceptions;
-  std::vector<cmStdString> m_CustomWarningMatches;
-  std::vector<cmStdString> m_CustomWarningExceptions;
-  std::vector<cmCTestCompileErrorWarningRex> m_ErrorWarningFileLineRegex;
+  std::vector<cmStdString> CustomErrorMatches;
+  std::vector<cmStdString> CustomErrorExceptions;
+  std::vector<cmStdString> CustomWarningMatches;
+  std::vector<cmStdString> CustomWarningExceptions;
+  std::vector<cmCTestCompileErrorWarningRex> ErrorWarningFileLineRegex;
 
-  std::vector<cmsys::RegularExpression> m_ErrorMatchRegex;
-  std::vector<cmsys::RegularExpression> m_ErrorExceptionRegex;
-  std::vector<cmsys::RegularExpression> m_WarningMatchRegex;
-  std::vector<cmsys::RegularExpression> m_WarningExceptionRegex;
+  std::vector<cmsys::RegularExpression> ErrorMatchRegex;
+  std::vector<cmsys::RegularExpression> ErrorExceptionRegex;
+  std::vector<cmsys::RegularExpression> WarningMatchRegex;
+  std::vector<cmsys::RegularExpression> WarningExceptionRegex;
 
   typedef std::deque<char> t_BuildProcessingQueueType;
 
@@ -109,31 +109,31 @@ private:
     size_t tick_len, std::ofstream& ofs, t_BuildProcessingQueueType* queue);
   int ProcessSingleLine(const char* data);
 
-  t_BuildProcessingQueueType            m_BuildProcessingQueue;
-  t_BuildProcessingQueueType            m_BuildProcessingErrorQueue;
-  size_t                                m_BuildOutputLogSize;
-  std::vector<char>                     m_CurrentProcessingLine;
+  t_BuildProcessingQueueType            BuildProcessingQueue;
+  t_BuildProcessingQueueType            BuildProcessingErrorQueue;
+  size_t                                BuildOutputLogSize;
+  std::vector<char>                     CurrentProcessingLine;
 
-  cmStdString                           m_SimplifySourceDir;
-  cmStdString                           m_SimplifyBuildDir;
-  size_t                                m_OutputLineCounter;
+  cmStdString                           SimplifySourceDir;
+  cmStdString                           SimplifyBuildDir;
+  size_t                                OutputLineCounter;
   typedef std::vector<cmCTestBuildErrorWarning> t_ErrorsAndWarningsVector;
-  t_ErrorsAndWarningsVector             m_ErrorsAndWarnings;
-  t_ErrorsAndWarningsVector::iterator   m_LastErrorOrWarning;
-  size_t                                m_PostContextCount;
-  size_t                                m_MaxPreContext;
-  size_t                                m_MaxPostContext;
-  std::deque<cmStdString>               m_PreContext;
-
-  int                                   m_TotalErrors;
-  int                                   m_TotalWarnings;
-  char                                  m_LastTickChar;
-
-  bool                                  m_ErrorQuotaReached;
-  bool                                  m_WarningQuotaReached;
-
-  int                                   m_MaxErrors;
-  int                                   m_MaxWarnings;
+  t_ErrorsAndWarningsVector             ErrorsAndWarnings;
+  t_ErrorsAndWarningsVector::iterator   LastErrorOrWarning;
+  size_t                                PostContextCount;
+  size_t                                MaxPreContext;
+  size_t                                MaxPostContext;
+  std::deque<cmStdString>               PreContext;
+
+  int                                   TotalErrors;
+  int                                   TotalWarnings;
+  char                                  LastTickChar;
+
+  bool                                  ErrorQuotaReached;
+  bool                                  WarningQuotaReached;
+
+  int                                   MaxErrors;
+  int                                   MaxWarnings;
 };
 
 #endif
diff --git a/Source/CTest/cmCTestCommand.h b/Source/CTest/cmCTestCommand.h
index 418b5af..55fe545 100644
--- a/Source/CTest/cmCTestCommand.h
+++ b/Source/CTest/cmCTestCommand.h
@@ -9,8 +9,8 @@
   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
 
-     This software is distributed WITHOUT ANY WARRANTY; without even 
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
      PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
@@ -27,17 +27,17 @@ class cmCTestScriptHandler;
  *
  * cmCTestCommand is the superclass for all commands that will be added to
  * the ctest script handlers parser.
- * 
+ *
  */
 class cmCTestCommand : public cmCommand
 {
 public:
 
-  cmCTestCommand() {m_CTest = 0; m_CTestScriptHandler = 0;}
-  
-  cmCTest *m_CTest;
-  cmCTestScriptHandler *m_CTestScriptHandler;
-  
+  cmCTestCommand() {this->CTest = 0; this->CTestScriptHandler = 0;}
+
+  cmCTest *CTest;
+  cmCTestScriptHandler *CTestScriptHandler;
+
   cmTypeMacro(cmCTestCommand, cmCommand);
 };
 
diff --git a/Source/CTest/cmCTestConfigureCommand.cxx b/Source/CTest/cmCTestConfigureCommand.cxx
index bb5623b..dd95cc0 100644
--- a/Source/CTest/cmCTestConfigureCommand.cxx
+++ b/Source/CTest/cmCTestConfigureCommand.cxx
@@ -88,7 +88,7 @@ bool cmCTestConfigureCommand::InitialPass(
 
   if ( source_dir )
     {
-    m_CTest->SetCTestConfiguration("SourceDirectory", source_dir);
+    this->CTest->SetCTestConfiguration("SourceDirectory", source_dir);
     }
   else
     {
@@ -97,7 +97,7 @@ bool cmCTestConfigureCommand::InitialPass(
 
   if ( build_dir )
     {
-    m_CTest->SetCTestConfiguration("BuildDirectory", build_dir);
+    this->CTest->SetCTestConfiguration("BuildDirectory", build_dir);
     }
   else
     {
@@ -116,7 +116,8 @@ bool cmCTestConfigureCommand::InitialPass(
     = m_Makefile->GetDefinition("CTEST_CONFIGURE_COMMAND");
   if ( ctestConfigureCommand && *ctestConfigureCommand )
     {
-    m_CTest->SetCTestConfiguration("ConfigureCommand", ctestConfigureCommand);
+    this->CTest->SetCTestConfiguration("ConfigureCommand",
+      ctestConfigureCommand);
     }
   else
     {
@@ -125,13 +126,13 @@ bool cmCTestConfigureCommand::InitialPass(
     if ( cmakeGeneratorName && *cmakeGeneratorName )
       {
       std::string cmakeConfigureCommand = "\"";
-      cmakeConfigureCommand += m_CTest->GetCMakeExecutable();
+      cmakeConfigureCommand += this->CTest->GetCMakeExecutable();
       cmakeConfigureCommand += "\" \"-G";
       cmakeConfigureCommand += cmakeGeneratorName;
       cmakeConfigureCommand += "\" \"";
       cmakeConfigureCommand += source_dir;
       cmakeConfigureCommand += "\"";
-      m_CTest->SetCTestConfiguration("ConfigureCommand",
+      this->CTest->SetCTestConfiguration("ConfigureCommand",
         cmakeConfigureCommand.c_str());
       }
     else
@@ -144,7 +145,7 @@ bool cmCTestConfigureCommand::InitialPass(
     }
 
   cmCTestGenericHandler* handler
-    = m_CTest->GetInitializedHandler("configure");
+    = this->CTest->GetInitializedHandler("configure");
   if ( !handler )
     {
     this->SetError(
diff --git a/Source/CTest/cmCTestConfigureCommand.h b/Source/CTest/cmCTestConfigureCommand.h
index 8ce199d..34b9a4d 100644
--- a/Source/CTest/cmCTestConfigureCommand.h
+++ b/Source/CTest/cmCTestConfigureCommand.h
@@ -36,8 +36,8 @@ public:
   virtual cmCommand* Clone()
     {
     cmCTestConfigureCommand* ni = new cmCTestConfigureCommand;
-    ni->m_CTest = this->m_CTest;
-    ni->m_CTestScriptHandler = this->m_CTestScriptHandler;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
     }
 
diff --git a/Source/CTest/cmCTestConfigureHandler.cxx b/Source/CTest/cmCTestConfigureHandler.cxx
index 3152fff..1a67289 100644
--- a/Source/CTest/cmCTestConfigureHandler.cxx
+++ b/Source/CTest/cmCTestConfigureHandler.cxx
@@ -39,21 +39,22 @@ void cmCTestConfigureHandler::Initialize()
 //functions and commented...
 int cmCTestConfigureHandler::ProcessHandler()
 {
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "Configure project" << std::endl);
-  std::string cCommand = m_CTest->GetCTestConfiguration("ConfigureCommand");
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "Configure project" << std::endl);
+  std::string cCommand
+    = this->CTest->GetCTestConfiguration("ConfigureCommand");
   if ( cCommand.size() == 0 )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE,
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
       "Cannot find ConfigureCommand key in the DartConfiguration.tcl"
       << std::endl);
     return -1;
     }
 
   std::string buildDirectory
-    = m_CTest->GetCTestConfiguration("BuildDirectory");
+    = this->CTest->GetCTestConfiguration("BuildDirectory");
   if ( buildDirectory.size() == 0 )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE,
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
       "Cannot find BuildDirectory  key in the DartConfiguration.tcl"
       << std::endl);
     return -1;
@@ -63,22 +64,22 @@ int cmCTestConfigureHandler::ProcessHandler()
   std::string output;
   int retVal = 0;
   int res = 0;
-  if ( !m_CTest->GetShowOnly() )
+  if ( !this->CTest->GetShowOnly() )
     {
     cmGeneratedFileStream os;
     if ( !this->StartResultingXML("Configure", os) )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open configure file"
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open configure file"
         << std::endl);
       return 1;
       }
-    std::string start_time = m_CTest->CurrentTime();
+    std::string start_time = this->CTest->CurrentTime();
 
     cmGeneratedFileStream ofs;
     this->StartLogFile("Configure", ofs);
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Configure with command: "
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Configure with command: "
       << cCommand.c_str() << std::endl);
-    res = m_CTest->RunMakeCommand(cCommand.c_str(), &output,
+    res = this->CTest->RunMakeCommand(cCommand.c_str(), &output,
       &retVal, buildDirectory.c_str(),
       0, ofs);
 
@@ -89,7 +90,7 @@ int cmCTestConfigureHandler::ProcessHandler()
 
     if ( os )
       {
-      m_CTest->StartXML(os);
+      this->CTest->StartXML(os);
       os << "<Configure>\n"
          << "\t<StartDateTime>" << start_time << "</StartDateTime>"
          << std::endl;
@@ -99,9 +100,9 @@ int cmCTestConfigureHandler::ProcessHandler()
         }
       os << "<ConfigureCommand>" << cCommand.c_str() << "</ConfigureCommand>"
         << std::endl;
-      cmCTestLog(m_CTest, DEBUG, "End" << std::endl);
+      cmCTestLog(this->CTest, DEBUG, "End" << std::endl);
       os << "<Log>" << cmCTest::MakeXMLSafe(output) << "</Log>" << std::endl;
-      std::string end_time = m_CTest->CurrentTime();
+      std::string end_time = this->CTest->CurrentTime();
       os << "\t<ConfigureStatus>" << retVal << "</ConfigureStatus>\n"
          << "\t<EndDateTime>" << end_time << "</EndDateTime>\n"
          << "<ElapsedMinutes>"
@@ -109,18 +110,18 @@ int cmCTestConfigureHandler::ProcessHandler()
            (cmSystemTools::GetTime() - elapsed_time_start)/6)/10.0
          << "</ElapsedMinutes>"
          << "</Configure>" << std::endl;
-      m_CTest->EndXML(os);
+      this->CTest->EndXML(os);
       }
     }
   else
     {
-    cmCTestLog(m_CTest, DEBUG, "Configure with command: " << cCommand
+    cmCTestLog(this->CTest, DEBUG, "Configure with command: " << cCommand
       << std::endl);
     }
   if (! res || retVal )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Error(s) when updating the project"
-      << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+      "Error(s) when updating the project" << std::endl);
     return -1;
     }
   return 0;
diff --git a/Source/CTest/cmCTestCoverageCommand.cxx b/Source/CTest/cmCTestCoverageCommand.cxx
index bcb3239..602bad1 100644
--- a/Source/CTest/cmCTestCoverageCommand.cxx
+++ b/Source/CTest/cmCTestCoverageCommand.cxx
@@ -71,13 +71,14 @@ bool cmCTestCoverageCommand::InitialPass(
 
   if ( build_dir )
     {
-    m_CTest->SetCTestConfiguration("BuildDirectory", build_dir);
+    this->CTest->SetCTestConfiguration("BuildDirectory", build_dir);
     }
 
-  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
     "CoverageCommand", "CTEST_COVERAGE_COMMAND");
 
-  cmCTestGenericHandler* handler = m_CTest->GetInitializedHandler("coverage");
+  cmCTestGenericHandler* handler
+    = this->CTest->GetInitializedHandler("coverage");
   if ( !handler )
     {
     this->SetError("internal CTest error. Cannot instantiate test handler");
@@ -85,7 +86,7 @@ bool cmCTestCoverageCommand::InitialPass(
     }
   std::string current_dir = cmSystemTools::GetCurrentWorkingDirectory();
   cmSystemTools::ChangeDirectory(
-    m_CTest->GetCTestConfiguration("BuildDirectory").c_str());
+    this->CTest->GetCTestConfiguration("BuildDirectory").c_str());
   int res = handler->ProcessHandler();
   if ( res_var )
     {
diff --git a/Source/CTest/cmCTestCoverageCommand.h b/Source/CTest/cmCTestCoverageCommand.h
index 703363a..afc2879 100644
--- a/Source/CTest/cmCTestCoverageCommand.h
+++ b/Source/CTest/cmCTestCoverageCommand.h
@@ -36,8 +36,8 @@ public:
   virtual cmCommand* Clone()
     {
     cmCTestCoverageCommand* ni = new cmCTestCoverageCommand;
-    ni->m_CTest = this->m_CTest;
-    ni->m_CTestScriptHandler = this->m_CTestScriptHandler;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
     }
 
diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx
index 0eacc42..f6280a3 100644
--- a/Source/CTest/cmCTestCoverageHandler.cxx
+++ b/Source/CTest/cmCTestCoverageHandler.cxx
@@ -40,7 +40,7 @@ cmCTestCoverageHandler::cmCTestCoverageHandler()
 void cmCTestCoverageHandler::Initialize()
 {
   this->Superclass::Initialize();
-  m_CustomCoverageExclude.empty();
+  this->CustomCoverageExclude.empty();
 }
 
 //----------------------------------------------------------------------
@@ -49,16 +49,16 @@ bool cmCTestCoverageHandler::StartCoverageLogFile(
 {
   char covLogFilename[1024];
   sprintf(covLogFilename, "CoverageLog-%d", logFileCount);
-  cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Open file: " << covLogFilename
-    << std::endl);
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Open file: "
+    << covLogFilename << std::endl);
   if (!this->StartResultingXML(covLogFilename, covLogFile) )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open log file: "
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open log file: "
       << covLogFilename << std::endl);
     return false;
     }
-  std::string local_start_time = m_CTest->CurrentTime();
-  m_CTest->StartXML(covLogFile);
+  std::string local_start_time = this->CTest->CurrentTime();
+  this->CTest->StartXML(covLogFile);
   covLogFile << "<CoverageLog>" << std::endl
     << "\t<StartDateTime>" << local_start_time << "</StartDateTime>"
     << std::endl;
@@ -69,13 +69,13 @@ bool cmCTestCoverageHandler::StartCoverageLogFile(
 void cmCTestCoverageHandler::EndCoverageLogFile(cmGeneratedFileStream& ostr,
   int logFileCount)
 {
-  std::string local_end_time = m_CTest->CurrentTime();
+  std::string local_end_time = this->CTest->CurrentTime();
   ostr << "\t<EndDateTime>" << local_end_time << "</EndDateTime>" << std::endl
     << "</CoverageLog>" << std::endl;
-  m_CTest->EndXML(ostr);
+  this->CTest->EndXML(ostr);
   char covLogFilename[1024];
   sprintf(covLogFilename, "CoverageLog-%d.xml", logFileCount);
-  cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Close file: "
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Close file: "
     << covLogFilename << std::endl);
   ostr.Close();
 }
@@ -86,12 +86,12 @@ bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file,
   const char* binDir)
 {
   std::vector<cmsys::RegularExpression>::iterator sit;
-  for ( sit = m_CustomCoverageExcludeRegex.begin();
-    sit != m_CustomCoverageExcludeRegex.end(); ++ sit )
+  for ( sit = this->CustomCoverageExcludeRegex.begin();
+    sit != this->CustomCoverageExcludeRegex.end(); ++ sit )
     {
     if ( sit->find(file) )
       {
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "  File " << file
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "  File " << file
         << " is excluded in CTestCustom.ctest" << std::endl;);
       return false;
       }
@@ -133,7 +133,7 @@ bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file,
       fFile.c_str(), checkDir.c_str());
   if ( ndc.size() )
     {
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Found: " << ndc.c_str()
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Found: " << ndc.c_str()
       << " so skip coverage of " << file << std::endl);
     return false;
     }
@@ -164,7 +164,7 @@ bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file,
     fFile.c_str(), checkDir.c_str());
   if ( ndc.size() )
     {
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Found: " << ndc.c_str()
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Found: " << ndc.c_str()
       << " so skip coverage of: " << file << std::endl);
     return false;
     }
@@ -179,16 +179,19 @@ int cmCTestCoverageHandler::ProcessHandler()
 {
   int error = 0;
 
-  std::string sourceDir = m_CTest->GetCTestConfiguration("SourceDirectory");
-  std::string binaryDir = m_CTest->GetCTestConfiguration("BuildDirectory");
-  std::string gcovCommand = m_CTest->GetCTestConfiguration("CoverageCommand");
+  std::string sourceDir
+    = this->CTest->GetCTestConfiguration("SourceDirectory");
+  std::string binaryDir
+    = this->CTest->GetCTestConfiguration("BuildDirectory");
+  std::string gcovCommand
+    = this->CTest->GetCTestConfiguration("CoverageCommand");
 
   cmGeneratedFileStream ofs;
   double elapsed_time_start = cmSystemTools::GetTime();
   if ( !this->StartLogFile("Coverage", ofs) )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create LastCoverage.log file"
-      << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+      "Cannot create LastCoverage.log file" << std::endl);
     }
 
   ofs << "Performing coverage: " << elapsed_time_start << std::endl;
@@ -224,11 +227,11 @@ int cmCTestCoverageHandler::ProcessHandler()
   cmsys::RegularExpression st2re5(st2gcovOutputRex5.c_str());
   cmsys::RegularExpression st2re6(st2gcovOutputRex6.c_str());
 
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "Performing coverage" << std::endl);
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "Performing coverage" << std::endl);
 
-  std::string coverage_start_time = m_CTest->CurrentTime();
+  std::string coverage_start_time = this->CTest->CurrentTime();
 
-  std::string testingDir = m_CTest->GetBinaryDir() + "/Testing";
+  std::string testingDir = this->CTest->GetBinaryDir() + "/Testing";
   std::string tempDir = testingDir + "/CoverageInfo";
   std::string currentDirectory = cmSystemTools::GetCurrentWorkingDirectory();
   cmSystemTools::MakeDirectory(tempDir.c_str());
@@ -247,19 +250,19 @@ int cmCTestCoverageHandler::ProcessHandler()
 
   if ( files.size() == 0 )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, " Cannot find any coverage files."
+    cmCTestLog(this->CTest, ERROR_MESSAGE, " Cannot find any coverage files."
       << std::endl);
     // No coverage files is a valid thing, so the exit code is 0
     return 0;
     }
 
-  m_CustomCoverageExcludeRegex.empty();
+  this->CustomCoverageExcludeRegex.empty();
   std::vector<cmStdString>::iterator rexIt;
-  for ( rexIt = m_CustomCoverageExclude.begin();
-    rexIt != m_CustomCoverageExclude.end();
+  for ( rexIt = this->CustomCoverageExclude.begin();
+    rexIt != this->CustomCoverageExclude.end();
     ++ rexIt )
     {
-    m_CustomCoverageExcludeRegex.push_back(
+    this->CustomCoverageExcludeRegex.push_back(
       cmsys::RegularExpression(rexIt->c_str()));
     }
 
@@ -273,44 +276,45 @@ int cmCTestCoverageHandler::ProcessHandler()
   std::set<std::string> missingFiles;
 
   std::string actualSourceFile = "";
-  cmCTestLog(m_CTest, HANDLER_OUTPUT,
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
     "   Processing coverage (each . represents one file):" << std::endl);
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "    ");
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "    ");
   int file_count = 0;
   for ( it = files.begin(); it != files.end(); ++ it )
     {
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "." << std::flush);
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "." << std::flush);
     std::string fileDir = cmSystemTools::GetFilenamePath(it->c_str());
     std::string command = "\"" + gcovCommand + "\" -l -o \"" + fileDir
       + "\" \"" + *it + "\"";
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, command.c_str() << std::endl);
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, command.c_str()
+      << std::endl);
     std::string output = "";
     std::string errors = "";
     int retVal = 0;
     ofs << "* Run coverage for: " << fileDir.c_str() << std::endl;
     ofs << "  Command: " << command.c_str() << std::endl;
-    int res = m_CTest->RunCommand(command.c_str(), &output, &errors,
-      &retVal, tempDir.c_str(), 0 /*m_TimeOut*/);
+    int res = this->CTest->RunCommand(command.c_str(), &output, &errors,
+      &retVal, tempDir.c_str(), 0 /*this->TimeOut*/);
 
     ofs << "  Output: " << output.c_str() << std::endl;
     ofs << "  Errors: " << errors.c_str() << std::endl;
     if ( ! res )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "Problem running coverage on file: "
-        << it->c_str() << std::endl);
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "Command produced error: " << errors
-        << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+        "Problem running coverage on file: " << it->c_str() << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+        "Command produced error: " << errors << std::endl);
       error ++;
       continue;
       }
     if ( retVal != 0 )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "Coverage command returned: "
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Coverage command returned: "
         << retVal << " while processing: " << it->c_str() << std::endl);
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "Command produced error: " << error
-        << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+        "Command produced error: " << error << std::endl);
       }
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT,
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
       "--------------------------------------------------------------"
       << std::endl
       << output << std::endl
@@ -326,7 +330,7 @@ int cmCTestCoverageHandler::ProcessHandler()
       {
       std::string sourceFile;
       std::string gcovFile;
-      cmCTestLog(m_CTest, DEBUG, "Line: [" << line->c_str() << "]"
+      cmCTestLog(this->CTest, DEBUG, "Line: [" << line->c_str() << "]"
         << std::endl);
       if ( line->size() == 0 )
         {
@@ -338,7 +342,7 @@ int cmCTestCoverageHandler::ProcessHandler()
           {
           if ( gcovStyle != 1 )
             {
-            cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+            cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style"
               << std::endl);
             error ++;
             break;
@@ -355,7 +359,7 @@ int cmCTestCoverageHandler::ProcessHandler()
           {
           if ( gcovStyle != 1 )
             {
-            cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+            cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style"
               << std::endl);
             error ++;
             break;
@@ -371,7 +375,7 @@ int cmCTestCoverageHandler::ProcessHandler()
           {
           if ( gcovStyle != 2 )
             {
-            cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+            cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style"
               << std::endl);
             error ++;
             break;
@@ -388,7 +392,7 @@ int cmCTestCoverageHandler::ProcessHandler()
           {
           if ( gcovStyle != 2 )
             {
-            cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+            cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style"
               << std::endl);
             error ++;
             break;
@@ -402,7 +406,7 @@ int cmCTestCoverageHandler::ProcessHandler()
           {
           if ( gcovStyle != 2 )
             {
-            cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+            cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style"
               << std::endl);
             error ++;
             break;
@@ -418,7 +422,7 @@ int cmCTestCoverageHandler::ProcessHandler()
           {
           if ( gcovStyle != 2 )
             {
-            cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+            cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style"
               << std::endl);
             error ++;
             break;
@@ -426,7 +430,7 @@ int cmCTestCoverageHandler::ProcessHandler()
           gcovStyle = 2;
           }
 
-        cmCTestLog(m_CTest, WARNING, "Warning: " << st2re4.match(1)
+        cmCTestLog(this->CTest, WARNING, "Warning: " << st2re4.match(1)
           << " had unexpected EOF" << std::endl);
         }
       else if ( st2re5.find(line->c_str() ) )
@@ -435,7 +439,7 @@ int cmCTestCoverageHandler::ProcessHandler()
           {
           if ( gcovStyle != 2 )
             {
-            cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+            cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style"
               << std::endl);
             error ++;
             break;
@@ -443,7 +447,7 @@ int cmCTestCoverageHandler::ProcessHandler()
           gcovStyle = 2;
           }
 
-        cmCTestLog(m_CTest, WARNING, "Warning: Cannot open file: "
+        cmCTestLog(this->CTest, WARNING, "Warning: Cannot open file: "
           << st2re5.match(1) << std::endl);
         }
       else if ( st2re6.find(line->c_str() ) )
@@ -452,7 +456,7 @@ int cmCTestCoverageHandler::ProcessHandler()
           {
           if ( gcovStyle != 2 )
             {
-            cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+            cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style"
               << std::endl);
             error ++;
             break;
@@ -460,25 +464,25 @@ int cmCTestCoverageHandler::ProcessHandler()
           gcovStyle = 2;
           }
 
-        cmCTestLog(m_CTest, WARNING, "Warning: File: " << st2re6.match(1)
+        cmCTestLog(this->CTest, WARNING, "Warning: File: " << st2re6.match(1)
           << " is newer than " << st2re6.match(2) << std::endl);
         }
       else
         {
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown line: [" << line->c_str()
-          << "]" << std::endl);
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+          "Unknown line: [" << line->c_str() << "]" << std::endl);
         error ++;
         //abort();
         }
       if ( !gcovFile.empty() && actualSourceFile.size() )
         {
         singleFileCoverageVector* vec = &totalCoverage[actualSourceFile];
-        cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "   in file: "
+        cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "   in file: "
           << gcovFile << std::endl);
         std::ifstream ifile(gcovFile.c_str());
         if ( ! ifile )
           {
-          cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open file: "
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open file: "
             << gcovFile << std::endl);
           }
         else
@@ -541,7 +545,7 @@ int cmCTestCoverageHandler::ProcessHandler()
           sourceFile.substr(0, sourceDir.size()) == sourceDir &&
           sourceFile[sourceDir.size()] == '/' )
           {
-          cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "   produced s: "
+          cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "   produced s: "
             << sourceFile.c_str() << std::endl);
           ofs << "  produced in source dir: " << sourceFile.c_str()
             << std::endl;
@@ -553,7 +557,7 @@ int cmCTestCoverageHandler::ProcessHandler()
           sourceFile.substr(0, binaryDir.size()) == binaryDir &&
           sourceFile[binaryDir.size()] == '/' )
           {
-          cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "   produced b: "
+          cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "   produced b: "
             << sourceFile.c_str() << std::endl);
           ofs << "  produced in binary dir: " << sourceFile.c_str()
             << std::endl;
@@ -564,13 +568,13 @@ int cmCTestCoverageHandler::ProcessHandler()
           {
           if ( missingFiles.find(actualSourceFile) == missingFiles.end() )
             {
-            cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Something went wrong"
-              << std::endl);
-            cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "File: ["
+            cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+              "Something went wrong" << std::endl);
+            cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "File: ["
               << sourceFile.c_str() << "]" << std::endl);
-            cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "s: ["
+            cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "s: ["
               << sourceFile.substr(0, sourceDir.size()) << "]" << std::endl);
-            cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "b: ["
+            cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "b: ["
               << sourceFile.substr(0, binaryDir.size()) << "]" << std::endl);
             ofs << "  Something went wrong. Cannot find: "
               << sourceFile.c_str()
@@ -584,9 +588,9 @@ int cmCTestCoverageHandler::ProcessHandler()
     file_count ++;
     if ( file_count % 50 == 0 )
       {
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, " processed: " << file_count
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, " processed: " << file_count
         << " out of " << files.size() << std::endl);
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, "    ");
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "    ");
       }
     }
 
@@ -595,13 +599,13 @@ int cmCTestCoverageHandler::ProcessHandler()
 
   if (!this->StartResultingXML("Coverage", covSumFile))
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open coverage summary file."
-      << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+      "Cannot open coverage summary file." << std::endl);
 
     return -1;
     }
 
-  m_CTest->StartXML(covSumFile);
+  this->CTest->StartXML(covSumFile);
   // Produce output xml files
 
   covSumFile << "<Coverage>" << std::endl
@@ -618,10 +622,10 @@ int cmCTestCoverageHandler::ProcessHandler()
   long total_untested = 0;
   //std::string fullSourceDir = sourceDir + "/";
   //std::string fullBinaryDir = binaryDir + "/";
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, std::endl);
-  cmCTestLog(m_CTest, HANDLER_OUTPUT,
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
     "   Acumulating results (each . represents one file):" << std::endl);
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "    ");
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "    ");
 
   std::vector<std::string> errorsWhileAccumulating;
 
@@ -630,14 +634,14 @@ int cmCTestCoverageHandler::ProcessHandler()
     fileIterator != totalCoverage.end();
     ++fileIterator )
     {
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "." << std::flush);
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "." << std::flush);
     file_count ++;
     if ( file_count % 50 == 0 )
       {
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, " processed: " << file_count
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, " processed: " << file_count
         << " out of "
         << totalCoverage.size() << std::endl);
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, "    ");
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "    ");
       }
     if ( cnt % 100 == 0 )
       {
@@ -653,14 +657,14 @@ int cmCTestCoverageHandler::ProcessHandler()
       = cmSystemTools::GetFilenameName(fullFileName.c_str());
     std::string fullFilePath
       = cmSystemTools::GetFilenamePath(fullFileName.c_str());
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Process file: "
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Process file: "
       << fullFileName << std::endl);
 
     cmSystemTools::ConvertToUnixSlashes(fullFilePath);
 
     if ( !cmSystemTools::FileExists(fullFileName.c_str()) )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot find file: "
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot find file: "
         << fullFileName.c_str() << std::endl);
       continue;
       }
@@ -670,7 +674,7 @@ int cmCTestCoverageHandler::ProcessHandler()
         sourceDir.c_str(), binaryDir.c_str());
     if ( !shouldIDoCoverage )
       {
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT,
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
         ".NoDartCoverage found, so skip coverage check for: "
         << fullFileName.c_str()
         << std::endl);
@@ -679,8 +683,9 @@ int cmCTestCoverageHandler::ProcessHandler()
 
     const singleFileCoverageVector& fcov = fileIterator->second;
     covLogFile << "\t<File Name=\""
-      << m_CTest->MakeXMLSafe(fileName.c_str())
-      << "\" FullPath=\"" << m_CTest->MakeXMLSafe(m_CTest->GetShortPathToFile(
+      << this->CTest->MakeXMLSafe(fileName.c_str())
+      << "\" FullPath=\"" << this->CTest->MakeXMLSafe(
+        this->CTest->GetShortPathToFile(
           fileIterator->first.c_str())) << "\">" << std::endl
       << "\t\t<Report>" << std::endl;
 
@@ -712,7 +717,7 @@ int cmCTestCoverageHandler::ProcessHandler()
         }
       covLogFile << "\t\t<Line Number=\"" << cc << "\" Count=\"" << fcov[cc]
         << "\">"
-        << m_CTest->MakeXMLSafe(line.c_str()) << "</Line>" << std::endl;
+        << this->CTest->MakeXMLSafe(line.c_str()) << "</Line>" << std::endl;
       if ( fcov[cc] == 0 )
         {
         untested ++;
@@ -741,9 +746,9 @@ int cmCTestCoverageHandler::ProcessHandler()
     total_untested += untested;
     covLogFile << "\t\t</Report>" << std::endl
       << "\t</File>" << std::endl;
-    covSumFile << "\t<File Name=\"" << m_CTest->MakeXMLSafe(fileName)
-      << "\" FullPath=\"" << m_CTest->MakeXMLSafe(
-        m_CTest->GetShortPathToFile(fullFileName.c_str()))
+    covSumFile << "\t<File Name=\"" << this->CTest->MakeXMLSafe(fileName)
+      << "\" FullPath=\"" << this->CTest->MakeXMLSafe(
+        this->CTest->GetShortPathToFile(fullFileName.c_str()))
       << "\" Covered=\"" << (cmet>0?"true":"false") << "\">\n"
       << "\t\t<LOCTested>" << tested << "</LOCTested>\n"
       << "\t\t<LOCUnTested>" << untested << "</LOCUnTested>\n"
@@ -762,15 +767,16 @@ int cmCTestCoverageHandler::ProcessHandler()
 
   if ( errorsWhileAccumulating.size() > 0 )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, std::endl);
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Error(s) while acumulating results:"
-      << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE, std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+      "Error(s) while acumulating results:" << std::endl);
     std::vector<std::string>::iterator erIt;
     for ( erIt = errorsWhileAccumulating.begin();
       erIt != errorsWhileAccumulating.end();
       ++ erIt )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "  " << erIt->c_str() << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+        "  " << erIt->c_str() << std::endl);
       }
     }
 
@@ -782,7 +788,7 @@ int cmCTestCoverageHandler::ProcessHandler()
     percent_coverage = 0;
     }
 
-  std::string end_time = m_CTest->CurrentTime();
+  std::string end_time = this->CTest->CurrentTime();
 
   covSumFile << "\t<LOCTested>" << total_tested << "</LOCTested>\n"
     << "\t<LOCUntested>" << total_untested << "</LOCUntested>\n"
@@ -796,9 +802,9 @@ int cmCTestCoverageHandler::ProcessHandler()
     static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start)/6)/10.0
     << "</ElapsedMinutes>"
     << "</Coverage>" << std::endl;
-  m_CTest->EndXML(covSumFile);
+  this->CTest->EndXML(covSumFile);
 
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "\tCovered LOC:         "
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "\tCovered LOC:         "
     << total_tested << std::endl
     << "\tNot covered LOC:     " << total_untested << std::endl
     << "\tTotal LOC:           " << total_lines << std::endl
@@ -827,16 +833,16 @@ int cmCTestCoverageHandler::ProcessHandler()
 //----------------------------------------------------------------------
 void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile *mf)
 {
-  cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT,
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
     " Add coverage exclude regular expressions." << std::endl);
   cmCTest::PopulateCustomVector(mf, "CTEST_CUSTOM_COVERAGE_EXCLUDE",
-                                m_CustomCoverageExclude);
+                                this->CustomCoverageExclude);
   std::vector<cmStdString>::iterator it;
-  for ( it = m_CustomCoverageExclude.begin();
-    it != m_CustomCoverageExclude.end();
+  for ( it = this->CustomCoverageExclude.begin();
+    it != this->CustomCoverageExclude.end();
     ++ it )
     {
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " Add coverage exclude: "
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, " Add coverage exclude: "
       << it->c_str() << std::endl);
     }
 }
diff --git a/Source/CTest/cmCTestCoverageHandler.h b/Source/CTest/cmCTestCoverageHandler.h
index 2102843..d2e798b 100644
--- a/Source/CTest/cmCTestCoverageHandler.h
+++ b/Source/CTest/cmCTestCoverageHandler.h
@@ -59,48 +59,48 @@ private:
     {
     cmCTestCoverage()
       {
-      m_AbsolutePath = "";
-      m_FullPath = "";
-      m_Covered = false;
-      m_Tested = 0;
-      m_UnTested = 0;
-      m_Lines.clear();
-      m_Show = false;
+      this->AbsolutePath = "";
+      this->FullPath = "";
+      this->Covered = false;
+      this->Tested = 0;
+      this->UnTested = 0;
+      this->Lines.clear();
+      this->Show = false;
       }
     cmCTestCoverage(const cmCTestCoverage& rhs) :
-      m_AbsolutePath(rhs.m_AbsolutePath),
-      m_FullPath(rhs.m_FullPath),
-      m_Covered(rhs.m_Covered),
-      m_Tested(rhs.m_Tested),
-      m_UnTested(rhs.m_UnTested),
-      m_Lines(rhs.m_Lines),
-      m_Show(rhs.m_Show)
+      AbsolutePath(rhs.AbsolutePath),
+      FullPath(rhs.FullPath),
+      Covered(rhs.Covered),
+      Tested(rhs.Tested),
+      UnTested(rhs.UnTested),
+      Lines(rhs.Lines),
+      Show(rhs.Show)
       {
       }
     cmCTestCoverage& operator=(const cmCTestCoverage& rhs)
       {
-      m_AbsolutePath = rhs.m_AbsolutePath;
-      m_FullPath = rhs.m_FullPath;
-      m_Covered = rhs.m_Covered;
-      m_Tested = rhs.m_Tested;
-      m_UnTested = rhs.m_UnTested;
-      m_Lines = rhs.m_Lines;
-      m_Show = rhs.m_Show;
+      this->AbsolutePath = rhs.AbsolutePath;
+      this->FullPath = rhs.FullPath;
+      this->Covered = rhs.Covered;
+      this->Tested = rhs.Tested;
+      this->UnTested = rhs.UnTested;
+      this->Lines = rhs.Lines;
+      this->Show = rhs.Show;
       return *this;
       }
-    std::string      m_AbsolutePath;
-    std::string      m_FullPath;
-    bool             m_Covered;
-    int              m_Tested;
-    int              m_UnTested;
-    std::vector<int> m_Lines;
-    bool             m_Show;
+    std::string      AbsolutePath;
+    std::string      FullPath;
+    bool             Covered;
+    int              Tested;
+    int              UnTested;
+    std::vector<int> Lines;
+    bool             Show;
     };
 
-  std::vector<cmStdString> m_CustomCoverageExclude;
-  std::vector<cmsys::RegularExpression> m_CustomCoverageExcludeRegex;
+  std::vector<cmStdString> CustomCoverageExclude;
+  std::vector<cmsys::RegularExpression> CustomCoverageExcludeRegex;
 
-  typedef std::map<std::string, cmCTestCoverage> tm_CoverageMap;
+  typedef std::map<std::string, cmCTestCoverage> CoverageMap;
 };
 
 #endif
diff --git a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
index 9b7e904..f6bd9a3 100644
--- a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
+++ b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
@@ -38,8 +38,8 @@ public:
     {
     cmCTestEmptyBinaryDirectoryCommand* ni
       = new cmCTestEmptyBinaryDirectoryCommand;
-    ni->m_CTest = this->m_CTest;
-    ni->m_CTestScriptHandler = this->m_CTestScriptHandler;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
     }
 
diff --git a/Source/CTest/cmCTestGenericHandler.cxx b/Source/CTest/cmCTestGenericHandler.cxx
index b5f964d..4c39842 100644
--- a/Source/CTest/cmCTestGenericHandler.cxx
+++ b/Source/CTest/cmCTestGenericHandler.cxx
@@ -22,9 +22,9 @@
 //----------------------------------------------------------------------
 cmCTestGenericHandler::cmCTestGenericHandler()
 {
-  m_HandlerVerbose = false;
-  m_CTest = 0;
-  m_SubmitIndex = 0;
+  this->HandlerVerbose = false;
+  this->CTest = 0;
+  this->SubmitIndex = 0;
 }
 
 //----------------------------------------------------------------------
@@ -42,29 +42,29 @@ void cmCTestGenericHandler::SetOption(const char* op, const char* value)
   if ( !value )
     {
     cmCTestGenericHandler::t_StringToString::iterator remit
-      = m_Options.find(op);
-    if ( remit != m_Options.end() )
+      = this->Options.find(op);
+    if ( remit != this->Options.end() )
       {
-      m_Options.erase(remit);
+      this->Options.erase(remit);
       }
     return;
     }
 
-  m_Options[op] = value;
+  this->Options[op] = value;
 }
 
 //----------------------------------------------------------------------
 void cmCTestGenericHandler::Initialize()
 {
-  m_Options.clear();
+  this->Options.clear();
 }
 
 //----------------------------------------------------------------------
 const char* cmCTestGenericHandler::GetOption(const char* op)
 {
   cmCTestGenericHandler::t_StringToString::iterator remit
-    = m_Options.find(op);
-  if ( remit == m_Options.end() )
+    = this->Options.find(op);
+  if ( remit == this->Options.end() )
     {
     return 0;
     }
@@ -77,26 +77,27 @@ bool cmCTestGenericHandler::StartResultingXML(const char* name,
 {
   if ( !name )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE,
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
       "Cannot create resulting XML file without providing the name"
       << std::endl;);
     return false;
     }
   cmOStringStream ostr;
   ostr << name;
-  if ( m_SubmitIndex > 0 )
+  if ( this->SubmitIndex > 0 )
     {
-    ostr << "_" << m_SubmitIndex;
+    ostr << "_" << this->SubmitIndex;
     }
   ostr << ".xml";
-  if( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), ostr.str().c_str(),
-      xofs, true) )
+  if( !this->CTest->OpenOutputFile(this->CTest->GetCurrentTag(),
+      ostr.str().c_str(), xofs, true) )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create resulting XML file: "
-      << ostr.str().c_str() << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+      "Cannot create resulting XML file: " << ostr.str().c_str()
+      << std::endl);
     return false;
     }
-  m_CTest->AddSubmitFile(ostr.str().c_str());
+  this->CTest->AddSubmitFile(ostr.str().c_str());
   return true;
 }
 
@@ -106,24 +107,24 @@ bool cmCTestGenericHandler::StartLogFile(const char* name,
 {
   if ( !name )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE,
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
       "Cannot create log file without providing the name" << std::endl;);
     return false;
     }
   cmOStringStream ostr;
   ostr << "Last" << name;
-  if ( m_SubmitIndex > 0 )
+  if ( this->SubmitIndex > 0 )
     {
-    ostr << "_" << m_SubmitIndex;
+    ostr << "_" << this->SubmitIndex;
     }
-  if ( !m_CTest->GetCurrentTag().empty() )
+  if ( !this->CTest->GetCurrentTag().empty() )
     {
-    ostr << "_" << m_CTest->GetCurrentTag();
+    ostr << "_" << this->CTest->GetCurrentTag();
     }
   ostr << ".log";
-  if( !m_CTest->OpenOutputFile("Temporary", ostr.str().c_str(), xofs) )
+  if( !this->CTest->OpenOutputFile("Temporary", ostr.str().c_str(), xofs) )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create log file: "
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create log file: "
       << ostr.str().c_str() << std::endl);
     return false;
     }
diff --git a/Source/CTest/cmCTestGenericHandler.h b/Source/CTest/cmCTestGenericHandler.h
index 4b8e699..9efa113 100644
--- a/Source/CTest/cmCTestGenericHandler.h
+++ b/Source/CTest/cmCTestGenericHandler.h
@@ -36,7 +36,7 @@ public:
   /**
    * If verbose then more informaiton is printed out
    */
-  void SetVerbose(bool val) { m_HandlerVerbose = val; }
+  void SetVerbose(bool val) { this->HandlerVerbose = val; }
 
   /**
    * Populate internals from CTest custom scripts
@@ -64,8 +64,8 @@ public:
   /**
    * Set the CTest instance
    */
-  void SetCTestInstance(cmCTest* ctest) { m_CTest = ctest; }
-  cmCTest* GetCTestInstance() { return m_CTest; }
+  void SetCTestInstance(cmCTest* ctest) { this->CTest = ctest; }
+  cmCTest* GetCTestInstance() { return this->CTest; }
 
   /**
    * Construct handler
@@ -80,22 +80,22 @@ public:
 
   void SetCommand(cmCTestCommand* command)
     {
-    m_Command = command;
+    this->Command = command;
     }
 
-  void SetSubmitIndex(int idx) { m_SubmitIndex = idx; }
-  int GetSubmitIndex() { return m_SubmitIndex; }
+  void SetSubmitIndex(int idx) { this->SubmitIndex = idx; }
+  int GetSubmitIndex() { return this->SubmitIndex; }
 
 protected:
   bool StartResultingXML(const char* name, cmGeneratedFileStream& xofs);
   bool StartLogFile(const char* name, cmGeneratedFileStream& xofs);
 
-  bool m_HandlerVerbose;
-  cmCTest *m_CTest;
-  t_StringToString m_Options;
+  bool HandlerVerbose;
+  cmCTest *CTest;
+  t_StringToString Options;
 
-  cmCTestCommand* m_Command;
-  int m_SubmitIndex;
+  cmCTestCommand* Command;
+  int SubmitIndex;
 };
 
 #endif
diff --git a/Source/CTest/cmCTestHandlerCommand.cxx b/Source/CTest/cmCTestHandlerCommand.cxx
index e030a5f..91bcb6c 100644
--- a/Source/CTest/cmCTestHandlerCommand.cxx
+++ b/Source/CTest/cmCTestHandlerCommand.cxx
@@ -23,23 +23,23 @@ cmCTestHandlerCommand::cmCTestHandlerCommand()
 {
   const size_t INIT_SIZE = 100;
   size_t cc;
-  m_Arguments.reserve(INIT_SIZE);
+  this->Arguments.reserve(INIT_SIZE);
   for ( cc = 0; cc < INIT_SIZE; ++ cc )
     {
-    m_Arguments.push_back(0);
+    this->Arguments.push_back(0);
     }
-  m_Arguments[ct_RETURN_VALUE] = "RETURN_VALUE";
-  m_Arguments[ct_SOURCE] = "SOURCE";
-  m_Arguments[ct_BUILD] = "BUILD";
-  m_Arguments[ct_SUBMIT_INDEX] = "SUBMIT_INDEX";
-  m_Last = ct_LAST;
+  this->Arguments[ct_RETURN_VALUE] = "RETURN_VALUE";
+  this->Arguments[ct_SOURCE] = "SOURCE";
+  this->Arguments[ct_BUILD] = "BUILD";
+  this->Arguments[ct_SUBMIT_INDEX] = "SUBMIT_INDEX";
+  this->Last = ct_LAST;
 }
 
 bool cmCTestHandlerCommand::InitialPass(
   std::vector<std::string> const& args)
 {
-  if ( !this->ProcessArguments(args, m_Last, &*m_Arguments.begin(),
-      m_Values) )
+  if ( !this->ProcessArguments(args, this->Last, &*this->Arguments.begin(),
+      this->Values) )
     {
     return false;
     }
@@ -51,15 +51,16 @@ bool cmCTestHandlerCommand::InitialPass(
     return false;
     }
 
-  if ( m_Values[ct_BUILD] )
+  if ( this->Values[ct_BUILD] )
     {
-    m_CTest->SetCTestConfiguration("BuildDirectory", m_Values[ct_BUILD]);
+    this->CTest->SetCTestConfiguration("BuildDirectory",
+      this->Values[ct_BUILD]);
     }
-  if ( m_Values[ct_SUBMIT_INDEX] )
+  if ( this->Values[ct_SUBMIT_INDEX] )
     {
-    if ( m_CTest->GetDartVersion() <= 1 )
+    if ( this->CTest->GetDartVersion() <= 1 )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE,
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
         "Dart before version 2.0 does not support collecting submissions."
         << std::endl
         << "Please upgrade the server to Dart 2 or higher, or do not use "
@@ -67,20 +68,21 @@ bool cmCTestHandlerCommand::InitialPass(
       }
     else
       {
-      handler->SetSubmitIndex(atoi(m_Values[ct_SUBMIT_INDEX]));
+      handler->SetSubmitIndex(atoi(this->Values[ct_SUBMIT_INDEX]));
       }
     }
 
 
   std::string current_dir = cmSystemTools::GetCurrentWorkingDirectory();
   cmSystemTools::ChangeDirectory(
-    m_CTest->GetCTestConfiguration("BuildDirectory").c_str());
+    this->CTest->GetCTestConfiguration("BuildDirectory").c_str());
   int res = handler->ProcessHandler();
-  if ( m_Values[ct_RETURN_VALUE] && *m_Values[ct_RETURN_VALUE])
+  if ( this->Values[ct_RETURN_VALUE] && *this->Values[ct_RETURN_VALUE])
     {
     cmOStringStream str;
     str << res;
-    m_Makefile->AddDefinition(m_Values[ct_RETURN_VALUE], str.str().c_str());
+    m_Makefile->AddDefinition(
+      this->Values[ct_RETURN_VALUE], str.str().c_str());
     }
   cmSystemTools::ChangeDirectory(current_dir.c_str());
   return true;
@@ -103,8 +105,7 @@ bool cmCTestHandlerCommand::ProcessArguments(
     if ( state > 0 && state < last )
       {
       values[state] = args[i].c_str();
-#undef cerr
-      cmCTestLog(m_CTest, DEBUG, "Set " << strings[state] << " to "
+      cmCTestLog(this->CTest, DEBUG, "Set " << strings[state] << " to "
         << args[i].c_str() << std::endl);
       state = 0;
       }
diff --git a/Source/CTest/cmCTestHandlerCommand.h b/Source/CTest/cmCTestHandlerCommand.h
index 1bdd188..69563e1 100644
--- a/Source/CTest/cmCTestHandlerCommand.h
+++ b/Source/CTest/cmCTestHandlerCommand.h
@@ -54,10 +54,10 @@ protected:
   bool ProcessArguments(std::vector<std::string> const& args,
     int last, const char** strings, std::vector<const char*>& values);
 
-  std::string m_ReturnVariable;
-  std::vector<const char*> m_Arguments;
-  std::vector<const char*> m_Values;
-  size_t m_Last;
+  std::string ReturnVariable;
+  std::vector<const char*> Arguments;
+  std::vector<const char*> Values;
+  size_t Last;
 };
 
 #endif
diff --git a/Source/CTest/cmCTestMemCheckCommand.cxx b/Source/CTest/cmCTestMemCheckCommand.cxx
index 7bf0463..a2e33a0 100644
--- a/Source/CTest/cmCTestMemCheckCommand.cxx
+++ b/Source/CTest/cmCTestMemCheckCommand.cxx
@@ -9,8 +9,8 @@
   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
 
-     This software is distributed WITHOUT ANY WARRANTY; without even 
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
      PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
@@ -22,13 +22,14 @@
 
 cmCTestGenericHandler* cmCTestMemCheckCommand::InitializeActualHandler()
 {
-  cmCTestGenericHandler* handler = m_CTest->GetInitializedHandler("memcheck");
+  cmCTestGenericHandler* handler
+    = this->CTest->GetInitializedHandler("memcheck");
 
-  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
     "MemoryCheckCommand", "CTEST_MEMORYCHECK_COMMAND");
-  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
     "MemoryCheckCommandOptions", "CTEST_MEMORYCHECK_COMMAND_OPTIONS");
-  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
     "MemoryCheckSuppressionFile", "CTEST_MEMORYCHECK_SUPPRESSIONS_FILE");
 
   return handler;
diff --git a/Source/CTest/cmCTestMemCheckCommand.h b/Source/CTest/cmCTestMemCheckCommand.h
index 443672d..94e6916 100644
--- a/Source/CTest/cmCTestMemCheckCommand.h
+++ b/Source/CTest/cmCTestMemCheckCommand.h
@@ -38,8 +38,8 @@ public:
   virtual cmCommand* Clone()
     {
     cmCTestMemCheckCommand* ni = new cmCTestMemCheckCommand;
-    ni->m_CTest = this->m_CTest;
-    ni->m_CTestScriptHandler = this->m_CTestScriptHandler;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
     }
 
diff --git a/Source/CTest/cmCTestMemCheckHandler.cxx b/Source/CTest/cmCTestMemCheckHandler.cxx
index bf529b1..4d4c527 100644
--- a/Source/CTest/cmCTestMemCheckHandler.cxx
+++ b/Source/CTest/cmCTestMemCheckHandler.cxx
@@ -87,22 +87,22 @@ static const char* cmCTestMemCheckResultLongStrings[] = {
 //----------------------------------------------------------------------
 cmCTestMemCheckHandler::cmCTestMemCheckHandler()
 {
-  m_MemCheck = true;
+  this->MemCheck = true;
 }
 
 //----------------------------------------------------------------------
 void cmCTestMemCheckHandler::Initialize()
 {
   this->Superclass::Initialize();
-  m_MemoryTester = "";
-  m_MemoryTesterOptionsParsed.clear();
-  m_MemoryTesterOptions = "";
-  m_MemoryTesterStyle = UNKNOWN;
-  m_MemoryTesterOutputFile = "";
+  this->MemoryTester = "";
+  this->MemoryTesterOptionsParsed.clear();
+  this->MemoryTesterOptions = "";
+  this->MemoryTesterStyle = UNKNOWN;
+  this->MemoryTesterOutputFile = "";
   int cc;
   for ( cc = 0; cc < NO_MEMORY_FAULT; cc ++ )
     {
-    m_MemoryTesterGlobalResults[cc] = 0;
+    this->MemoryTesterGlobalResults[cc] = 0;
     }
 
 }
@@ -115,9 +115,9 @@ int cmCTestMemCheckHandler::PreProcessHandler()
     return 0;
     }
 
-  if ( !this->ExecuteCommands(m_CustomPreMemCheck) )
+  if ( !this->ExecuteCommands(this->CustomPreMemCheck) )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE,
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
       "Problem executing pre-memcheck command(s)." << std::endl);
     return 0;
     }
@@ -127,9 +127,9 @@ int cmCTestMemCheckHandler::PreProcessHandler()
 //----------------------------------------------------------------------
 int cmCTestMemCheckHandler::PostProcessHandler()
 {
-  if ( !this->ExecuteCommands(m_CustomPostMemCheck) )
+  if ( !this->ExecuteCommands(this->CustomPostMemCheck) )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE,
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
       "Problem executing post-memcheck command(s)." << std::endl);
     return 0;
     }
@@ -141,17 +141,17 @@ void cmCTestMemCheckHandler::GenerateTestCommand(
   std::vector<const char*>& args)
 {
   std::vector<cmStdString>::size_type pp;
-  args.push_back(m_MemoryTester.c_str());
+  args.push_back(this->MemoryTester.c_str());
   std::string memcheckcommand = "";
-  memcheckcommand = m_MemoryTester;
-  for ( pp = 0; pp < m_MemoryTesterOptionsParsed.size(); pp ++ )
+  memcheckcommand = this->MemoryTester;
+  for ( pp = 0; pp < this->MemoryTesterOptionsParsed.size(); pp ++ )
     {
-    args.push_back(m_MemoryTesterOptionsParsed[pp].c_str());
+    args.push_back(this->MemoryTesterOptionsParsed[pp].c_str());
     memcheckcommand += " ";
     memcheckcommand += cmSystemTools::EscapeSpaces(
-      m_MemoryTesterOptionsParsed[pp].c_str());
+      this->MemoryTesterOptionsParsed[pp].c_str());
     }
-  cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Memory check command: "
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Memory check command: "
     << memcheckcommand << std::endl);
 }
 
@@ -160,26 +160,26 @@ void cmCTestMemCheckHandler::PopulateCustomVectors(cmMakefile *mf)
 {
   this->cmCTestTestHandler::PopulateCustomVectors(mf);
   cmCTest::PopulateCustomVector(mf, "CTEST_CUSTOM_PRE_MEMCHECK",
-                                m_CustomPreMemCheck);
+                                this->CustomPreMemCheck);
   cmCTest::PopulateCustomVector(mf, "CTEST_CUSTOM_POST_MEMCHECK",
-                                m_CustomPostMemCheck);
+                                this->CustomPostMemCheck);
 
   cmCTest::PopulateCustomVector(mf,
                              "CTEST_CUSTOM_MEMCHECK_IGNORE",
-                             m_CustomTestsIgnore);
+                             this->CustomTestsIgnore);
 }
 
 //----------------------------------------------------------------------
 void cmCTestMemCheckHandler::GenerateDartOutput(std::ostream& os)
 {
-  if ( !m_CTest->GetProduceXML() )
+  if ( !this->CTest->GetProduceXML() )
     {
     return;
     }
 
-  m_CTest->StartXML(os);
+  this->CTest->StartXML(os);
   os << "<DynamicAnalysis Checker=\"";
-  switch ( m_MemoryTesterStyle )
+  switch ( this->MemoryTesterStyle )
     {
     case cmCTestMemCheckHandler::VALGRIND:
       os << "Valgrind";
@@ -195,41 +195,41 @@ void cmCTestMemCheckHandler::GenerateDartOutput(std::ostream& os)
     }
   os << "\">" << std::endl;
 
-  os << "\t<StartDateTime>" << m_StartTest << "</StartDateTime>\n"
+  os << "\t<StartDateTime>" << this->StartTest << "</StartDateTime>\n"
     << "\t<TestList>\n";
-  tm_TestResultsVector::size_type cc;
-  for ( cc = 0; cc < m_TestResults.size(); cc ++ )
+  cmCTestMemCheckHandler::TestResultsVector::size_type cc;
+  for ( cc = 0; cc < this->TestResults.size(); cc ++ )
     {
-    cmCTestTestResult *result = &m_TestResults[cc];
-    std::string testPath = result->m_Path + "/" + result->m_Name;
+    cmCTestTestResult *result = &this->TestResults[cc];
+    std::string testPath = result->Path + "/" + result->Name;
     os << "\t\t<Test>" << cmCTest::MakeXMLSafe(
-      m_CTest->GetShortPathToFile(testPath.c_str()))
+      this->CTest->GetShortPathToFile(testPath.c_str()))
       << "</Test>" << std::endl;
     }
   os << "\t</TestList>\n";
-  cmCTestLog(m_CTest, HANDLER_OUTPUT,
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
     "-- Processing memory checking output: ");
-  unsigned int total = m_TestResults.size();
+  unsigned int total = this->TestResults.size();
   unsigned int step = total / 10;
   unsigned int current = 0;
-  for ( cc = 0; cc < m_TestResults.size(); cc ++ )
+  for ( cc = 0; cc < this->TestResults.size(); cc ++ )
     {
-    cmCTestTestResult *result = &m_TestResults[cc];
+    cmCTestTestResult *result = &this->TestResults[cc];
     std::string memcheckstr;
     int memcheckresults[cmCTestMemCheckHandler::NO_MEMORY_FAULT];
     int kk;
-    bool res = this->ProcessMemCheckOutput(result->m_Output, memcheckstr,
+    bool res = this->ProcessMemCheckOutput(result->Output, memcheckstr,
       memcheckresults);
-    if ( res && result->m_Status == cmCTestMemCheckHandler::COMPLETED )
+    if ( res && result->Status == cmCTestMemCheckHandler::COMPLETED )
       {
       continue;
       }
     os << "\t<Test Status=\"";
-    if ( result->m_Status == cmCTestMemCheckHandler::COMPLETED )
+    if ( result->Status == cmCTestMemCheckHandler::COMPLETED )
       {
       os << "passed";
       }
-    else if ( result->m_Status == cmCTestMemCheckHandler::NOT_RUN )
+    else if ( result->Status == cmCTestMemCheckHandler::NOT_RUN )
       {
       os << "notrun";
       }
@@ -237,15 +237,15 @@ void cmCTestMemCheckHandler::GenerateDartOutput(std::ostream& os)
       {
       os << "failed";
       }
-    std::string testPath = result->m_Path + "/" + result->m_Name;
+    std::string testPath = result->Path + "/" + result->Name;
     os << "\">\n"
-      << "\t\t<Name>" << cmCTest::MakeXMLSafe(result->m_Name) << "</Name>\n"
+      << "\t\t<Name>" << cmCTest::MakeXMLSafe(result->Name) << "</Name>\n"
       << "\t\t<Path>" << cmCTest::MakeXMLSafe(
-        m_CTest->GetShortPathToFile(result->m_Path.c_str())) << "</Path>\n"
+        this->CTest->GetShortPathToFile(result->Path.c_str())) << "</Path>\n"
       << "\t\t<FullName>" << cmCTest::MakeXMLSafe(
-        m_CTest->GetShortPathToFile(testPath.c_str())) << "</FullName>\n"
+        this->CTest->GetShortPathToFile(testPath.c_str())) << "</FullName>\n"
       << "\t\t<FullCommandLine>"
-      << cmCTest::MakeXMLSafe(result->m_FullCommandLine)
+      << cmCTest::MakeXMLSafe(result->FullCommandLine)
       << "</FullCommandLine>\n"
       << "\t\t<Results>" << std::endl;
     for ( kk = 0; cmCTestMemCheckResultLongStrings[kk]; kk ++ )
@@ -257,7 +257,7 @@ void cmCTestMemCheckHandler::GenerateDartOutput(std::ostream& os)
            << memcheckresults[kk]
            << "</Defect>" << std::endl;
         }
-      m_MemoryTesterGlobalResults[kk] += memcheckresults[kk];
+      this->MemoryTesterGlobalResults[kk] += memcheckresults[kk];
       }
     os
       << "\t\t</Results>\n"
@@ -266,39 +266,39 @@ void cmCTestMemCheckHandler::GenerateDartOutput(std::ostream& os)
       << "\t</Test>" << std::endl;
     if ( current < cc )
       {
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, "#" << std::flush);
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "#" << std::flush);
       current += step;
       }
     }
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, std::endl);
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "Memory checking results:"
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "Memory checking results:"
     << std::endl);
   os << "\t<DefectList>" << std::endl;
   for ( cc = 0; cmCTestMemCheckResultStrings[cc]; cc ++ )
     {
-    if ( m_MemoryTesterGlobalResults[cc] )
+    if ( this->MemoryTesterGlobalResults[cc] )
       {
 #ifdef cerr
 #  undef cerr
 #endif
       std::cerr.width(35);
 #define cerr no_cerr
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, cmCTestMemCheckResultLongStrings[cc]
-        << " - "
-        << m_MemoryTesterGlobalResults[cc] << std::endl);
+      cmCTestLog(this->CTest, HANDLER_OUTPUT,
+        cmCTestMemCheckResultLongStrings[cc] << " - "
+        << this->MemoryTesterGlobalResults[cc] << std::endl);
       os << "\t\t<Defect Type=\"" << cmCTestMemCheckResultLongStrings[cc]
         << "\"/>" << std::endl;
       }
     }
   os << "\t</DefectList>" << std::endl;
 
-  os << "\t<EndDateTime>" << m_EndTest << "</EndDateTime>" << std::endl;
+  os << "\t<EndDateTime>" << this->EndTest << "</EndDateTime>" << std::endl;
   os << "<ElapsedMinutes>"
-     << static_cast<int>(m_ElapsedTestingTime/6)/10.0
+     << static_cast<int>(this->ElapsedTestingTime/6)/10.0
      << "</ElapsedMinutes>\n";
 
   os << "</DynamicAnalysis>" << std::endl;
-  m_CTest->EndXML(os);
+  this->CTest->EndXML(os);
 
 
 }
@@ -307,111 +307,118 @@ void cmCTestMemCheckHandler::GenerateDartOutput(std::ostream& os)
 bool cmCTestMemCheckHandler::InitializeMemoryChecking()
 {
   // Setup the command
-  if ( cmSystemTools::FileExists(m_CTest->GetCTestConfiguration(
+  if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
         "MemoryCheckCommand").c_str()) )
     {
-    m_MemoryTester
-      = cmSystemTools::ConvertToOutputPath(m_CTest->GetCTestConfiguration(
+    this->MemoryTester
+      = cmSystemTools::ConvertToOutputPath(this->CTest->GetCTestConfiguration(
           "MemoryCheckCommand").c_str());
     }
-  else if ( cmSystemTools::FileExists(m_CTest->GetCTestConfiguration(
+  else if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
         "PurifyCommand").c_str()) )
     {
-    m_MemoryTester
-      = cmSystemTools::ConvertToOutputPath(m_CTest->GetCTestConfiguration(
+    this->MemoryTester
+      = cmSystemTools::ConvertToOutputPath(this->CTest->GetCTestConfiguration(
           "PurifyCommand").c_str());
     }
-  else if ( cmSystemTools::FileExists(m_CTest->GetCTestConfiguration(
+  else if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
         "ValgrindCommand").c_str()) )
     {
-    m_MemoryTester
-      = cmSystemTools::ConvertToOutputPath(m_CTest->GetCTestConfiguration(
+    this->MemoryTester
+      = cmSystemTools::ConvertToOutputPath(this->CTest->GetCTestConfiguration(
           "ValgrindCommand").c_str());
     }
   else
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Memory checker (MemoryCheckCommand) "
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+      "Memory checker (MemoryCheckCommand) "
       "not set, or cannot find the specified program."
       << std::endl);
     return false;
     }
 
-  if ( m_MemoryTester[0] == '\"' &&
-    m_MemoryTester[m_MemoryTester.size()-1] == '\"' )
+  if ( this->MemoryTester[0] == '\"' &&
+    this->MemoryTester[this->MemoryTester.size()-1] == '\"' )
     {
-    m_MemoryTester = m_MemoryTester.substr(1, m_MemoryTester.size()-2);
+    this->MemoryTester
+      = this->MemoryTester.substr(1, this->MemoryTester.size()-2);
     }
 
   // Setup the options
-  if ( m_CTest->GetCTestConfiguration("MemoryCheckCommandOptions").size() )
+  if ( this->CTest->GetCTestConfiguration(
+      "MemoryCheckCommandOptions").size() )
     {
-    m_MemoryTesterOptions = m_CTest->GetCTestConfiguration(
+    this->MemoryTesterOptions = this->CTest->GetCTestConfiguration(
       "MemoryCheckCommandOptions");
     }
-  else if ( m_CTest->GetCTestConfiguration("ValgrindCommandOptions").size() )
+  else if ( this->CTest->GetCTestConfiguration(
+      "ValgrindCommandOptions").size() )
     {
-    m_MemoryTesterOptions = m_CTest->GetCTestConfiguration(
+    this->MemoryTesterOptions = this->CTest->GetCTestConfiguration(
       "ValgrindCommandOptions");
     }
 
-  m_MemoryTesterOutputFile
-    = m_CTest->GetBinaryDir() + "/Testing/Temporary/MemoryChecker.log";
-  m_MemoryTesterOutputFile
-    = cmSystemTools::EscapeSpaces(m_MemoryTesterOutputFile.c_str());
+  this->MemoryTesterOutputFile
+    = this->CTest->GetBinaryDir() + "/Testing/Temporary/MemoryChecker.log";
+  this->MemoryTesterOutputFile
+    = cmSystemTools::EscapeSpaces(this->MemoryTesterOutputFile.c_str());
 
-  if ( m_MemoryTester.find("valgrind") != std::string::npos )
+  if ( this->MemoryTester.find("valgrind") != std::string::npos )
     {
-    m_MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND;
-    if ( !m_MemoryTesterOptions.size() )
+    this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND;
+    if ( !this->MemoryTesterOptions.size() )
       {
-      m_MemoryTesterOptions = "-q --tool=memcheck --leak-check=yes "
+      this->MemoryTesterOptions = "-q --tool=memcheck --leak-check=yes "
         "--show-reachable=yes --workaround-gcc296-bugs=yes --num-callers=100";
       }
-    if ( m_CTest->GetCTestConfiguration("MemoryCheckSuppressionFile").size() )
+    if ( this->CTest->GetCTestConfiguration(
+        "MemoryCheckSuppressionFile").size() )
       {
-      if ( !cmSystemTools::FileExists(m_CTest->GetCTestConfiguration(
+      if ( !cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
             "MemoryCheckSuppressionFile").c_str()) )
         {
-        cmCTestLog(m_CTest, ERROR_MESSAGE,
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
           "Cannot find memory checker suppression file: "
-          << m_CTest->GetCTestConfiguration(
+          << this->CTest->GetCTestConfiguration(
             "MemoryCheckSuppressionFile").c_str() << std::endl);
         return false;
         }
-      m_MemoryTesterOptions += " --suppressions=" +
-        cmSystemTools::EscapeSpaces(m_CTest->GetCTestConfiguration(
+      this->MemoryTesterOptions += " --suppressions=" +
+        cmSystemTools::EscapeSpaces(this->CTest->GetCTestConfiguration(
             "MemoryCheckSuppressionFile").c_str()) + "";
       }
     }
-  else if ( m_MemoryTester.find("purify") != std::string::npos )
+  else if ( this->MemoryTester.find("purify") != std::string::npos )
     {
-    m_MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY;
+    this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY;
 #ifdef _WIN32
-    m_MemoryTesterOptions += " /SAVETEXTDATA=" + m_MemoryTesterOutputFile;
+    this->MemoryTesterOptions += " /SAVETEXTDATA=" +
+      this->MemoryTesterOutputFile;
 #else
-    m_MemoryTesterOptions += " -log-file=" + m_MemoryTesterOutputFile;
+    this->MemoryTesterOptions += " -log-file=" + this->MemoryTesterOutputFile;
 #endif
     }
-  else if ( m_MemoryTester.find("boundschecker") != std::string::npos )
+  else if ( this->MemoryTester.find("boundschecker") != std::string::npos )
     {
-    m_MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Bounds checker not yet implemented"
-      << std::endl);
+    this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+      "Bounds checker not yet implemented" << std::endl);
     return false;
     }
   else
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Do not understand memory checker: "
-      << m_MemoryTester.c_str() << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+      "Do not understand memory checker: " << this->MemoryTester.c_str()
+      << std::endl);
     return false;
     }
 
-  m_MemoryTesterOptionsParsed
-    = cmSystemTools::ParseArguments(m_MemoryTesterOptions.c_str());
+  this->MemoryTesterOptionsParsed
+    = cmSystemTools::ParseArguments(this->MemoryTesterOptions.c_str());
   std::vector<cmStdString>::size_type cc;
   for ( cc = 0; cmCTestMemCheckResultStrings[cc]; cc ++ )
     {
-    m_MemoryTesterGlobalResults[cc] = 0;
+    this->MemoryTesterGlobalResults[cc] = 0;
     }
   return true;
 }
@@ -426,15 +433,16 @@ bool cmCTestMemCheckHandler::ProcessMemCheckOutput(const std::string& str,
     results[cc] = 0;
     }
 
-  if ( m_MemoryTesterStyle == cmCTestMemCheckHandler::VALGRIND )
+  if ( this->MemoryTesterStyle == cmCTestMemCheckHandler::VALGRIND )
     {
     return this->ProcessMemCheckValgrindOutput(str, log, results);
     }
-  else if ( m_MemoryTesterStyle == cmCTestMemCheckHandler::PURIFY )
+  else if ( this->MemoryTesterStyle == cmCTestMemCheckHandler::PURIFY )
     {
     return this->ProcessMemCheckPurifyOutput(str, log, results);
     }
-  else if ( m_MemoryTesterStyle == cmCTestMemCheckHandler::BOUNDS_CHECKER )
+  else if ( this->MemoryTesterStyle ==
+    cmCTestMemCheckHandler::BOUNDS_CHECKER )
     {
     log.append("\nMemory checking style used was: ");
     log.append("Bounds Checker");
@@ -455,18 +463,18 @@ bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput(
   const std::string&, std::string& log,
   int* results)
 {
-  if ( !cmSystemTools::FileExists(m_MemoryTesterOutputFile.c_str()) )
+  if ( !cmSystemTools::FileExists(this->MemoryTesterOutputFile.c_str()) )
     {
-    log = "Cannot find Purify output file: " + m_MemoryTesterOutputFile;
-    cmCTestLog(m_CTest, ERROR_MESSAGE, log.c_str() << std::endl);
+    log = "Cannot find Purify output file: " + this->MemoryTesterOutputFile;
+    cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl);
     return false;
     }
 
-  std::ifstream ifs(m_MemoryTesterOutputFile.c_str());
+  std::ifstream ifs(this->MemoryTesterOutputFile.c_str());
   if ( !ifs )
     {
-    log = "Cannot read Purify output file: " + m_MemoryTesterOutputFile;
-    cmCTestLog(m_CTest, ERROR_MESSAGE, log.c_str() << std::endl);
+    log = "Cannot read Purify output file: " + this->MemoryTesterOutputFile;
+    cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl);
     return false;
     }
 
@@ -494,7 +502,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput(
         }
       if ( cc == cmCTestMemCheckHandler::NO_MEMORY_FAULT )
         {
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown Purify memory fault: "
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown Purify memory fault: "
           << pfW.match(1) << std::endl);
         ostr << "*** Unknown Purify memory fault: " << pfW.match(1)
           << std::endl;
@@ -562,7 +570,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
     "locked by a different thread");
 
   double sttime = cmSystemTools::GetTime();
-  cmCTestLog(m_CTest, DEBUG, "Start test: " << lines.size() << std::endl);
+  cmCTestLog(this->CTest, DEBUG, "Start test: " << lines.size() << std::endl);
   for ( cc = 0; cc < lines.size(); cc ++ )
     {
     if ( valgrindLine.find(lines[cc]) )
@@ -630,7 +638,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
       ostr << cmCTest::MakeXMLSafe(lines[cc]) << std::endl;
       }
     }
-  cmCTestLog(m_CTest, DEBUG, "End test (elapsed: "
+  cmCTestLog(this->CTest, DEBUG, "End test (elapsed: "
     << (cmSystemTools::GetTime() - sttime) << std::endl);
   log = ostr.str();
   if ( defects )
diff --git a/Source/CTest/cmCTestMemCheckHandler.h b/Source/CTest/cmCTestMemCheckHandler.h
index 483e2d6..8a21d48 100644
--- a/Source/CTest/cmCTestMemCheckHandler.h
+++ b/Source/CTest/cmCTestMemCheckHandler.h
@@ -91,12 +91,12 @@ private:
     COMPLETED
   };
 
-  std::string              m_MemoryTester;
-  std::vector<cmStdString> m_MemoryTesterOptionsParsed;
-  std::string              m_MemoryTesterOptions;
-  int                      m_MemoryTesterStyle;
-  std::string              m_MemoryTesterOutputFile;
-  int                      m_MemoryTesterGlobalResults[NO_MEMORY_FAULT];
+  std::string              MemoryTester;
+  std::vector<cmStdString> MemoryTesterOptionsParsed;
+  std::string              MemoryTesterOptions;
+  int                      MemoryTesterStyle;
+  std::string              MemoryTesterOutputFile;
+  int                      MemoryTesterGlobalResults[NO_MEMORY_FAULT];
 
   ///! Initialize memory checking subsystem.
   bool InitializeMemoryChecking();
@@ -106,8 +106,8 @@ private:
    */
   void GenerateDartOutput(std::ostream& os);
 
-  std::vector<cmStdString> m_CustomPreMemCheck;
-  std::vector<cmStdString> m_CustomPostMemCheck;
+  std::vector<cmStdString> CustomPreMemCheck;
+  std::vector<cmStdString> CustomPostMemCheck;
 
   //! Parse Valgrind/Purify/Bounds Checker result out of the output
   //string. After running, log holds the output and results hold the
diff --git a/Source/CTest/cmCTestRunScriptCommand.cxx b/Source/CTest/cmCTestRunScriptCommand.cxx
index 80c13f8..5df84bb 100644
--- a/Source/CTest/cmCTestRunScriptCommand.cxx
+++ b/Source/CTest/cmCTestRunScriptCommand.cxx
@@ -23,7 +23,7 @@ bool cmCTestRunScriptCommand::InitialPass(
 {
   if(args.size() < 1 )
     {
-    m_CTestScriptHandler->RunCurrentScript();
+    this->CTestScriptHandler->RunCurrentScript();
     return true;
     }
 
@@ -31,7 +31,7 @@ bool cmCTestRunScriptCommand::InitialPass(
   unsigned int i;
   for (i = 0; i < args.size(); ++i)
     {
-    cmCTestScriptHandler::RunScript(m_CTest, args[i].c_str());
+    cmCTestScriptHandler::RunScript(this->CTest, args[i].c_str());
     }
   return true;
 }
diff --git a/Source/CTest/cmCTestRunScriptCommand.h b/Source/CTest/cmCTestRunScriptCommand.h
index 9bf1f3b..1ca022e 100644
--- a/Source/CTest/cmCTestRunScriptCommand.h
+++ b/Source/CTest/cmCTestRunScriptCommand.h
@@ -37,8 +37,8 @@ public:
   virtual cmCommand* Clone() 
     {
     cmCTestRunScriptCommand* ni = new cmCTestRunScriptCommand;
-    ni->m_CTest = this->m_CTest;
-    ni->m_CTestScriptHandler = this->m_CTestScriptHandler;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
     }
 
diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx
index 67d556d..f832710 100644
--- a/Source/CTest/cmCTestScriptHandler.cxx
+++ b/Source/CTest/cmCTestScriptHandler.cxx
@@ -68,77 +68,77 @@ public:
   //virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf);
   //virtual void ScopeEnded(cmMakefile &mf);
 
-  cmCTestScriptHandler* m_CTestScriptHandler;
+  cmCTestScriptHandler* CTestScriptHandler;
 };
 
 // simply update the time and don't block anything
 bool cmCTestScriptFunctionBlocker::
 IsFunctionBlocked(const cmListFileFunction& , cmMakefile &)
 {
-  m_CTestScriptHandler->UpdateElapsedTime();
+  this->CTestScriptHandler->UpdateElapsedTime();
   return false;
 }
 
 //----------------------------------------------------------------------
 cmCTestScriptHandler::cmCTestScriptHandler()
 {
-  m_Backup = false;
-  m_EmptyBinDir = false;
-  m_EmptyBinDirOnce = false;
-  m_Makefile = 0;
-  m_LocalGenerator = 0;
-  m_CMake = 0;
-  m_GlobalGenerator = 0;
+  this->Backup = false;
+  this->EmptyBinDir = false;
+  this->EmptyBinDirOnce = false;
+  this->Makefile = 0;
+  this->LocalGenerator = 0;
+  this->CMake = 0;
+  this->GlobalGenerator = 0;
 
-  m_ScriptStartTime = 0;
+  this->ScriptStartTime = 0;
 
   // the *60 is becuase the settings are in minutes but GetTime is seconds
-  m_MinimumInterval = 30*60;
-  m_ContinuousDuration = -1;
+  this->MinimumInterval = 30*60;
+  this->ContinuousDuration = -1;
 }
 
 //----------------------------------------------------------------------
 void cmCTestScriptHandler::Initialize()
 {
   this->Superclass::Initialize();
-  m_Backup = false;
-  m_EmptyBinDir = false;
-  m_EmptyBinDirOnce = false;
-
-  m_SourceDir = "";
-  m_BinaryDir = "";
-  m_BackupSourceDir = "";
-  m_BackupBinaryDir = "";
-  m_CTestRoot = "";
-  m_CVSCheckOut = "";
-  m_CTestCmd = "";
-  m_CVSCmd = "";
-  m_CTestEnv = "";
-  m_InitCache = "";
-  m_CMakeCmd = "";
-  m_CMOutFile = "";
-  m_ExtraUpdates.clear();
-
-  m_MinimumInterval = 20*60;
-  m_ContinuousDuration = -1;
+  this->Backup = false;
+  this->EmptyBinDir = false;
+  this->EmptyBinDirOnce = false;
+
+  this->SourceDir = "";
+  this->BinaryDir = "";
+  this->BackupSourceDir = "";
+  this->BackupBinaryDir = "";
+  this->CTestRoot = "";
+  this->CVSCheckOut = "";
+  this->CTestCmd = "";
+  this->CVSCmd = "";
+  this->CTestEnv = "";
+  this->InitCache = "";
+  this->CMakeCmd = "";
+  this->CMOutFile = "";
+  this->ExtraUpdates.clear();
+
+  this->MinimumInterval = 20*60;
+  this->ContinuousDuration = -1;
 
   // what time in seconds did this script start running
-  m_ScriptStartTime = 0;
+  this->ScriptStartTime = 0;
 
-  m_Makefile = 0;
-  if (m_LocalGenerator)
+  this->Makefile = 0;
+  if (this->LocalGenerator)
     {
-    delete m_LocalGenerator;
+    delete this->LocalGenerator;
     }
-  m_LocalGenerator = 0;
-  if (m_GlobalGenerator)
+  this->LocalGenerator = 0;
+  if (this->GlobalGenerator)
     {
-    delete m_GlobalGenerator;
+    delete this->GlobalGenerator;
     }
-  m_GlobalGenerator = 0;
-  if (m_CMake)
+  this->GlobalGenerator = 0;
+  if (this->CMake)
     {
-    delete m_CMake;
+    delete this->CMake;
     }
 }
 
@@ -146,20 +146,20 @@ void cmCTestScriptHandler::Initialize()
 cmCTestScriptHandler::~cmCTestScriptHandler()
 {
   // local generator owns the makefile
-  m_Makefile = 0;
-  if (m_LocalGenerator)
+  this->Makefile = 0;
+  if (this->LocalGenerator)
     {
-    delete m_LocalGenerator;
+    delete this->LocalGenerator;
     }
-  m_LocalGenerator = 0;
-  if (m_GlobalGenerator)
+  this->LocalGenerator = 0;
+  if (this->GlobalGenerator)
     {
-    delete m_GlobalGenerator;
+    delete this->GlobalGenerator;
     }
-  m_GlobalGenerator = 0;
-  if (m_CMake)
+  this->GlobalGenerator = 0;
+  if (this->CMake)
     {
-    delete m_CMake;
+    delete this->CMake;
     }
 }
 
@@ -168,7 +168,7 @@ cmCTestScriptHandler::~cmCTestScriptHandler()
 // just adds an argument to the vector
 void cmCTestScriptHandler::AddConfigurationScript(const char *script)
 {
-  m_ConfigurationScripts.push_back(script);
+  this->ConfigurationScripts.push_back(script);
 }
 
 
@@ -179,8 +179,8 @@ int cmCTestScriptHandler::ProcessHandler()
 {
   int res = 0;
   std::vector<cmStdString>::iterator it;
-  for ( it = m_ConfigurationScripts.begin();
-        it != m_ConfigurationScripts.end();
+  for ( it = this->ConfigurationScripts.begin();
+        it != this->ConfigurationScripts.end();
         it ++ )
     {
     // for each script run it
@@ -196,14 +196,14 @@ int cmCTestScriptHandler::ProcessHandler()
 
 void cmCTestScriptHandler::UpdateElapsedTime()
 {
-  if (m_LocalGenerator)
+  if (this->LocalGenerator)
     {
     // set the current elapsed time
     char timeString[20];
     int itime = static_cast<unsigned int>(cmSystemTools::GetTime()
-                                          - m_ScriptStartTime);
+                                          - this->ScriptStartTime);
     sprintf(timeString,"%i",itime);
-    m_LocalGenerator->GetMakefile()->AddDefinition("CTEST_ELAPSED_TIME",
+    this->LocalGenerator->GetMakefile()->AddDefinition("CTEST_ELAPSED_TIME",
                                                    timeString);
     }
 }
@@ -212,9 +212,9 @@ void cmCTestScriptHandler::UpdateElapsedTime()
 void cmCTestScriptHandler::AddCTestCommand(cmCTestCommand* command)
 {
   cmCTestCommand* newCom = command;
-  newCom->m_CTest = m_CTest;
-  newCom->m_CTestScriptHandler = this;
-  m_CMake->AddCommand(newCom);
+  newCom->CTest = this->CTest;
+  newCom->CTestScriptHandler = this;
+  this->CMake->AddCommand(newCom);
 }
 
 //----------------------------------------------------------------------
@@ -242,31 +242,31 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg)
 
   // create a cmake instance to read the configuration script
   // read in the list file to fill the cache
-  if (m_CMake)
+  if (this->CMake)
     {
-    delete m_CMake;
-    delete m_GlobalGenerator;
-    delete m_LocalGenerator;
+    delete this->CMake;
+    delete this->GlobalGenerator;
+    delete this->LocalGenerator;
     }
-  m_CMake = new cmake;
-  m_CMake->AddCMakePaths(m_CTest->GetCTestExecutable());
-  m_GlobalGenerator = new cmGlobalGenerator;
-  m_GlobalGenerator->SetCMakeInstance(m_CMake);
+  this->CMake = new cmake;
+  this->CMake->AddCMakePaths(this->CTest->GetCTestExecutable());
+  this->GlobalGenerator = new cmGlobalGenerator;
+  this->GlobalGenerator->SetCMakeInstance(this->CMake);
 
-  m_LocalGenerator = m_GlobalGenerator->CreateLocalGenerator();
-  m_LocalGenerator->SetGlobalGenerator(m_GlobalGenerator);
-  m_Makefile = m_LocalGenerator->GetMakefile();
+  this->LocalGenerator = this->GlobalGenerator->CreateLocalGenerator();
+  this->LocalGenerator->SetGlobalGenerator(this->GlobalGenerator);
+  this->Makefile = this->LocalGenerator->GetMakefile();
 
   // set a variable with the path to the current script
-  m_Makefile->AddDefinition("CTEST_SCRIPT_DIRECTORY",
+  this->Makefile->AddDefinition("CTEST_SCRIPT_DIRECTORY",
                             cmSystemTools::GetFilenamePath(script).c_str());
-  m_Makefile->AddDefinition("CTEST_SCRIPT_NAME",
+  this->Makefile->AddDefinition("CTEST_SCRIPT_NAME",
                             cmSystemTools::GetFilenameName(script).c_str());
-  m_Makefile->AddDefinition("CTEST_EXECUTABLE_NAME",
-                            m_CTest->GetCTestExecutable());
-  m_Makefile->AddDefinition("CMAKE_EXECUTABLE_NAME",
-                            m_CTest->GetCMakeExecutable());
-  m_Makefile->AddDefinition("CTEST_RUN_CURRENT_SCRIPT", true);
+  this->Makefile->AddDefinition("CTEST_EXECUTABLE_NAME",
+                            this->CTest->GetCTestExecutable());
+  this->Makefile->AddDefinition("CMAKE_EXECUTABLE_NAME",
+                            this->CTest->GetCMakeExecutable());
+  this->Makefile->AddDefinition("CTEST_RUN_CURRENT_SCRIPT", true);
   this->UpdateElapsedTime();
 
   // add any ctest specific commands, probably should have common superclass
@@ -287,16 +287,16 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg)
   // add the script arg if defined
   if (script_arg.size())
     {
-    m_Makefile->AddDefinition("CTEST_SCRIPT_ARG", script_arg.c_str());
+    this->Makefile->AddDefinition("CTEST_SCRIPT_ARG", script_arg.c_str());
     }
 
   // always add a function blocker to update the elapsed time
   cmCTestScriptFunctionBlocker *f = new cmCTestScriptFunctionBlocker();
-  f->m_CTestScriptHandler = this;
-  m_Makefile->AddFunctionBlocker(f);
+  f->CTestScriptHandler = this;
+  this->Makefile->AddFunctionBlocker(f);
 
   // finally read in the script
-  if (!m_Makefile->ReadListFile(0, script.c_str()))
+  if (!this->Makefile->ReadListFile(0, script.c_str()))
     {
     return 2;
     }
@@ -313,47 +313,59 @@ int cmCTestScriptHandler::ExtractVariables()
   const char* minInterval;
   const char* contDuration;
 
-  m_SourceDir   = m_Makefile->GetSafeDefinition("CTEST_SOURCE_DIRECTORY");
-  m_BinaryDir   = m_Makefile->GetSafeDefinition("CTEST_BINARY_DIRECTORY");
-  m_CTestCmd    = m_Makefile->GetSafeDefinition("CTEST_COMMAND");
-  m_CVSCheckOut = m_Makefile->GetSafeDefinition("CTEST_CVS_CHECKOUT");
-  m_CTestRoot   = m_Makefile->GetSafeDefinition("CTEST_DASHBOARD_ROOT");
-  m_CVSCmd      = m_Makefile->GetSafeDefinition("CTEST_CVS_COMMAND");
-  m_CTestEnv    = m_Makefile->GetSafeDefinition("CTEST_ENVIRONMENT");
-  m_InitCache   = m_Makefile->GetSafeDefinition("CTEST_INITIAL_CACHE");
-  m_CMakeCmd    = m_Makefile->GetSafeDefinition("CTEST_CMAKE_COMMAND");
-  m_CMOutFile
-    = m_Makefile->GetSafeDefinition("CTEST_CMAKE_OUTPUT_FILE_NAME");
-
-  m_Backup      = m_Makefile->IsOn("CTEST_BACKUP_AND_RESTORE");
-  m_EmptyBinDir = m_Makefile->IsOn("CTEST_START_WITH_EMPTY_BINARY_DIRECTORY");
-  m_EmptyBinDirOnce
-    = m_Makefile->IsOn("CTEST_START_WITH_EMPTY_BINARY_DIRECTORY_ONCE");
+  this->SourceDir
+    = this->Makefile->GetSafeDefinition("CTEST_SOURCE_DIRECTORY");
+  this->BinaryDir
+    = this->Makefile->GetSafeDefinition("CTEST_BINARY_DIRECTORY");
+  this->CTestCmd
+    = this->Makefile->GetSafeDefinition("CTEST_COMMAND");
+  this->CVSCheckOut
+    = this->Makefile->GetSafeDefinition("CTEST_CVS_CHECKOUT");
+  this->CTestRoot
+    = this->Makefile->GetSafeDefinition("CTEST_DASHBOARD_ROOT");
+  this->CVSCmd
+    = this->Makefile->GetSafeDefinition("CTEST_CVS_COMMAND");
+  this->CTestEnv
+    = this->Makefile->GetSafeDefinition("CTEST_ENVIRONMENT");
+  this->InitCache
+    = this->Makefile->GetSafeDefinition("CTEST_INITIAL_CACHE");
+  this->CMakeCmd
+    = this->Makefile->GetSafeDefinition("CTEST_CMAKE_COMMAND");
+  this->CMOutFile
+    = this->Makefile->GetSafeDefinition("CTEST_CMAKE_OUTPUT_FILE_NAME");
+
+  this->Backup
+    = this->Makefile->IsOn("CTEST_BACKUP_AND_RESTORE");
+  this->EmptyBinDir
+    = this->Makefile->IsOn("CTEST_START_WITH_EMPTY_BINARY_DIRECTORY");
+  this->EmptyBinDirOnce
+    = this->Makefile->IsOn("CTEST_START_WITH_EMPTY_BINARY_DIRECTORY_ONCE");
 
   minInterval
-    = m_Makefile->GetDefinition("CTEST_CONTINUOUS_MINIMUM_INTERVAL");
-  contDuration  = m_Makefile->GetDefinition("CTEST_CONTINUOUS_DURATION");
+    = this->Makefile->GetDefinition("CTEST_CONTINUOUS_MINIMUM_INTERVAL");
+  contDuration
+    = this->Makefile->GetDefinition("CTEST_CONTINUOUS_DURATION");
 
   char updateVar[40];
   int i;
   for (i = 1; i < 10; ++i)
     {
     sprintf(updateVar,"CTEST_EXTRA_UPDATES_%i",i);
-    const char *updateVal = m_Makefile->GetDefinition(updateVar);
+    const char *updateVal = this->Makefile->GetDefinition(updateVar);
     if ( updateVal )
       {
-      if ( m_CVSCmd.empty() )
+      if ( this->CVSCmd.empty() )
         {
         cmSystemTools::Error(updateVar,
           " specified without specifying CTEST_CVS_COMMAND.");
         return 12;
         }
-      m_ExtraUpdates.push_back(updateVal);
+      this->ExtraUpdates.push_back(updateVal);
       }
     }
 
   // in order to backup and restore we also must have the cvs root
-  if (m_Backup && m_CVSCheckOut.empty())
+  if (this->Backup && this->CVSCheckOut.empty())
     {
     cmSystemTools::Error(
       "Backup was requested without specifying CTEST_CVS_CHECKOUT.");
@@ -361,37 +373,37 @@ int cmCTestScriptHandler::ExtractVariables()
     }
 
   // make sure the required info is here
-  if (this->m_SourceDir.empty() ||
-      this->m_BinaryDir.empty() ||
-      this->m_CTestCmd.empty())
-    {
-    std::string message = "CTEST_SOURCE_DIRECTORY = ";
-    message += (!m_SourceDir.empty()) ? m_SourceDir.c_str() : "(Null)";
-    message += "\nCTEST_BINARY_DIRECTORY = ";
-    message += (!m_BinaryDir.empty()) ? m_BinaryDir.c_str() : "(Null)";
-    message += "\nCTEST_COMMAND = ";
-    message += (!m_CTestCmd.empty()) ? m_CTestCmd.c_str() : "(Null)";
+  if (this->SourceDir.empty() ||
+      this->BinaryDir.empty() ||
+      this->CTestCmd.empty())
+    {
+    std::string msg = "CTEST_SOURCE_DIRECTORY = ";
+    msg += (!this->SourceDir.empty()) ? this->SourceDir.c_str() : "(Null)";
+    msg += "\nCTEST_BINARY_DIRECTORY = ";
+    msg += (!this->BinaryDir.empty()) ? this->BinaryDir.c_str() : "(Null)";
+    msg += "\nCTEST_COMMAND = ";
+    msg += (!this->CTestCmd.empty()) ? this->CTestCmd.c_str() : "(Null)";
     cmSystemTools::Error(
       "Some required settings in the configuration file were missing:\n",
-      message.c_str());
+      msg.c_str());
     return 4;
     }
 
   // if the dashboard root isn't specified then we can compute it from the
-  // m_SourceDir
-  if (m_CTestRoot.empty() )
+  // this->SourceDir
+  if (this->CTestRoot.empty() )
     {
-    m_CTestRoot = cmSystemTools::GetFilenamePath(m_SourceDir).c_str();
+    this->CTestRoot = cmSystemTools::GetFilenamePath(this->SourceDir).c_str();
     }
 
   // the script may override the minimum continuous interval
   if (minInterval)
     {
-    m_MinimumInterval = 60 * atof(minInterval);
+    this->MinimumInterval = 60 * atof(minInterval);
     }
   if (contDuration)
     {
-    m_ContinuousDuration = 60.0 * atof(contDuration);
+    this->ContinuousDuration = 60.0 * atof(contDuration);
     }
 
 
@@ -417,7 +429,7 @@ int cmCTestScriptHandler::RunConfigurationScript(
 {
   int result;
 
-  m_ScriptStartTime =
+  this->ScriptStartTime =
     cmSystemTools::GetTime();
 
   // read in the script
@@ -428,7 +440,7 @@ int cmCTestScriptHandler::RunConfigurationScript(
     }
 
   // only run the curent script if we should
-  if (m_Makefile && m_Makefile->IsOn("CTEST_RUN_CURRENT_SCRIPT"))
+  if (this->Makefile && this->Makefile->IsOn("CTEST_RUN_CURRENT_SCRIPT"))
     {
     return this->RunCurrentScript();
     }
@@ -441,7 +453,7 @@ int cmCTestScriptHandler::RunCurrentScript()
   int result;
 
   // do not run twice
-  m_Makefile->AddDefinition("CTEST_RUN_CURRENT_SCRIPT", false);
+  this->Makefile->AddDefinition("CTEST_RUN_CURRENT_SCRIPT", false);
 
   // no popup widows
   cmSystemTools::SetRunCommandHideConsole(true);
@@ -454,10 +466,10 @@ int cmCTestScriptHandler::RunCurrentScript()
     }
 
   // set any environment variables
-  if (!m_CTestEnv.empty())
+  if (!this->CTestEnv.empty())
     {
     std::vector<std::string> envArgs;
-    cmSystemTools::ExpandListArgument(m_CTestEnv.c_str(),envArgs);
+    cmSystemTools::ExpandListArgument(this->CTestEnv.c_str(),envArgs);
     // for each variable/argument do a putenv
     for (unsigned i = 0; i < envArgs.size(); ++i)
       {
@@ -468,27 +480,27 @@ int cmCTestScriptHandler::RunCurrentScript()
   // now that we have done most of the error checking finally run the
   // dashboard, we may be asked to repeatedly run this dashboard, such as
   // for a continuous, do we ned to run it more than once?
-  if ( m_ContinuousDuration >= 0 )
+  if ( this->ContinuousDuration >= 0 )
     {
     this->UpdateElapsedTime();
-    double ending_time  = cmSystemTools::GetTime() + m_ContinuousDuration;
-    if (m_EmptyBinDirOnce)
+    double ending_time  = cmSystemTools::GetTime() + this->ContinuousDuration;
+    if (this->EmptyBinDirOnce)
       {
-      m_EmptyBinDir = true;
+      this->EmptyBinDir = true;
       }
     do
       {
       double interval = cmSystemTools::GetTime();
       result = this->RunConfigurationDashboard();
       interval = cmSystemTools::GetTime() - interval;
-      if (interval < m_MinimumInterval)
+      if (interval < this->MinimumInterval)
         {
         this->SleepInSeconds(
-          static_cast<unsigned int>(m_MinimumInterval - interval));
+          static_cast<unsigned int>(this->MinimumInterval - interval));
         }
-      if (m_EmptyBinDirOnce)
+      if (this->EmptyBinDirOnce)
         {
-        m_EmptyBinDir = false;
+        this->EmptyBinDir = false;
         }
       }
     while (cmSystemTools::GetTime() < ending_time);
@@ -510,16 +522,16 @@ int cmCTestScriptHandler::CheckOutSourceDir()
   int retVal;
   bool res;
 
-  if (!cmSystemTools::FileExists(m_SourceDir.c_str()) &&
-      !m_CVSCheckOut.empty())
+  if (!cmSystemTools::FileExists(this->SourceDir.c_str()) &&
+      !this->CVSCheckOut.empty())
     {
     // we must now checkout the src dir
     output = "";
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Run cvs: " << m_CVSCheckOut
-      << std::endl);
-    res = cmSystemTools::RunSingleCommand(m_CVSCheckOut.c_str(), &output,
-                                          &retVal, m_CTestRoot.c_str(),
-                                          m_HandlerVerbose, 0 /*m_TimeOut*/);
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+      "Run cvs: " << this->CVSCheckOut << std::endl);
+    res = cmSystemTools::RunSingleCommand(this->CVSCheckOut.c_str(), &output,
+      &retVal, this->CTestRoot.c_str(), this->HandlerVerbose,
+      0 /*this->TimeOut*/);
     if (!res || retVal != 0)
       {
       cmSystemTools::Error("Unable to perform cvs checkout:\n",
@@ -536,27 +548,27 @@ int cmCTestScriptHandler::BackupDirectories()
   int retVal;
 
   // compute the backup names
-  m_BackupSourceDir = m_SourceDir;
-  m_BackupSourceDir += "_CMakeBackup";
-  m_BackupBinaryDir = m_BinaryDir;
-  m_BackupBinaryDir += "_CMakeBackup";
+  this->BackupSourceDir = this->SourceDir;
+  this->BackupSourceDir += "_CMakeBackup";
+  this->BackupBinaryDir = this->BinaryDir;
+  this->BackupBinaryDir += "_CMakeBackup";
 
   // backup the binary and src directories if requested
-  if (m_Backup)
+  if (this->Backup)
     {
     // if for some reason those directories exist then first delete them
-    if (cmSystemTools::FileExists(m_BackupSourceDir.c_str()))
+    if (cmSystemTools::FileExists(this->BackupSourceDir.c_str()))
       {
-      cmSystemTools::RemoveADirectory(m_BackupSourceDir.c_str());
+      cmSystemTools::RemoveADirectory(this->BackupSourceDir.c_str());
       }
-    if (cmSystemTools::FileExists(m_BackupBinaryDir.c_str()))
+    if (cmSystemTools::FileExists(this->BackupBinaryDir.c_str()))
       {
-      cmSystemTools::RemoveADirectory(m_BackupBinaryDir.c_str());
+      cmSystemTools::RemoveADirectory(this->BackupBinaryDir.c_str());
       }
 
     // first rename the src and binary directories
-    rename(m_SourceDir.c_str(), m_BackupSourceDir.c_str());
-    rename(m_BinaryDir.c_str(), m_BackupBinaryDir.c_str());
+    rename(this->SourceDir.c_str(), this->BackupSourceDir.c_str());
+    rename(this->BinaryDir.c_str(), this->BackupBinaryDir.c_str());
 
     // we must now checkout the src dir
     retVal = this->CheckOutSourceDir();
@@ -580,9 +592,11 @@ int cmCTestScriptHandler::PerformExtraUpdates()
   bool res;
 
   // do an initial cvs update as required
-  command = m_CVSCmd;
+  command = this->CVSCmd;
   std::vector<cmStdString>::iterator it;
-  for (it = m_ExtraUpdates.begin(); it != m_ExtraUpdates.end(); ++ it )
+  for (it = this->ExtraUpdates.begin();
+    it != this->ExtraUpdates.end();
+    ++ it )
     {
     std::vector<std::string> cvsArgs;
     cmSystemTools::ExpandListArgument(it->c_str(),cvsArgs);
@@ -593,11 +607,11 @@ int cmCTestScriptHandler::PerformExtraUpdates()
       fullCommand += cvsArgs[1];
       output = "";
       retVal = 0;
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Run CVS: "
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run CVS: "
         << fullCommand.c_str() << std::endl);
       res = cmSystemTools::RunSingleCommand(fullCommand.c_str(), &output,
         &retVal, cvsArgs[0].c_str(),
-        m_HandlerVerbose, 0 /*m_TimeOut*/);
+        this->HandlerVerbose, 0 /*this->TimeOut*/);
       if (!res || retVal != 0)
         {
         cmSystemTools::Error("Unable to perform extra cvs updates:\n",
@@ -636,23 +650,24 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
     }
 
   // clear the binary directory?
-  if (m_EmptyBinDir)
+  if (this->EmptyBinDir)
     {
-    if ( !cmCTestScriptHandler::EmptyBinaryDirectory(m_BinaryDir.c_str()) )
+    if ( !cmCTestScriptHandler::EmptyBinaryDirectory(
+        this->BinaryDir.c_str()) )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE,
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
         "Problem removing the binary directory" << std::endl);
       }
     }
 
   // make sure the binary directory exists if it isn't the srcdir
-  if (!cmSystemTools::FileExists(m_BinaryDir.c_str()) &&
-      m_SourceDir != m_BinaryDir)
+  if (!cmSystemTools::FileExists(this->BinaryDir.c_str()) &&
+      this->SourceDir != this->BinaryDir)
     {
-    if (!cmSystemTools::MakeDirectory(m_BinaryDir.c_str()))
+    if (!cmSystemTools::MakeDirectory(this->BinaryDir.c_str()))
       {
       cmSystemTools::Error("Unable to create the binary directory:\n",
-                           m_BinaryDir.c_str());
+                           this->BinaryDir.c_str());
       this->RestoreBackupDirectories();
       return 7;
       }
@@ -661,10 +676,10 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
   // if the binary directory and the source directory are the same,
   // and we are starting with an empty binary directory, then that means
   // we must check out the source tree
-  if (m_EmptyBinDir && m_SourceDir == m_BinaryDir)
+  if (this->EmptyBinDir && this->SourceDir == this->BinaryDir)
     {
     // make sure we have the required info
-    if (m_CVSCheckOut.empty())
+    if (this->CVSCheckOut.empty())
       {
       cmSystemTools::Error("You have specified the source and binary "
         "directories to be the same (an in source build). You have also "
@@ -691,9 +706,9 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
     }
 
   // put the initial cache into the bin dir
-  if (!m_InitCache.empty())
+  if (!this->InitCache.empty())
     {
-    std::string cacheFile = m_BinaryDir;
+    std::string cacheFile = this->BinaryDir;
     cacheFile += "/CMakeCache.txt";
     cmGeneratedFileStream fout(cacheFile.c_str());
     if(!fout)
@@ -702,7 +717,7 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
       return 9;
       }
 
-    fout.write(m_InitCache.c_str(), m_InitCache.size());
+    fout.write(this->InitCache.c_str(), this->InitCache.size());
 
     // Make sure the operating system has finished writing the file
     // before closing it.  This will ensure the file is finished before
@@ -714,29 +729,29 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
   // do an initial cmake to setup the DartConfig file
   int cmakeFailed = 0;
   std::string cmakeFailedOuput;
-  if (!m_CMakeCmd.empty())
+  if (!this->CMakeCmd.empty())
     {
-    command = m_CMakeCmd;
+    command = this->CMakeCmd;
     command += " \"";
-    command += m_SourceDir;
+    command += this->SourceDir;
     output = "";
     command += "\"";
     retVal = 0;
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Run cmake command: "
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run cmake command: "
       << command.c_str() << std::endl);
     res = cmSystemTools::RunSingleCommand(command.c_str(), &output,
-      &retVal, m_BinaryDir.c_str(),
-      m_HandlerVerbose, 0 /*m_TimeOut*/);
+      &retVal, this->BinaryDir.c_str(),
+      this->HandlerVerbose, 0 /*this->TimeOut*/);
 
-    if ( !m_CMOutFile.empty() )
+    if ( !this->CMOutFile.empty() )
       {
-      std::string cmakeOutputFile = m_CMOutFile;
+      std::string cmakeOutputFile = this->CMOutFile;
       if ( !cmSystemTools::FileIsFullPath(cmakeOutputFile.c_str()) )
         {
-        cmakeOutputFile = m_BinaryDir + "/" + cmakeOutputFile;
+        cmakeOutputFile = this->BinaryDir + "/" + cmakeOutputFile;
         }
 
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT,
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
         "Write CMake output to file: " << cmakeOutputFile.c_str()
         << std::endl);
       cmGeneratedFileStream fout(cmakeOutputFile.c_str());
@@ -746,7 +761,8 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
         }
       else
         {
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open CMake output file: "
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+          "Cannot open CMake output file: "
           << cmakeOutputFile.c_str() << " for writing" << std::endl);
         }
       }
@@ -760,18 +776,18 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
 
   // run ctest, it may be more than one command in here
   std::vector<std::string> ctestCommands;
-  cmSystemTools::ExpandListArgument(m_CTestCmd,ctestCommands);
+  cmSystemTools::ExpandListArgument(this->CTestCmd,ctestCommands);
   // for each variable/argument do a putenv
   for (unsigned i = 0; i < ctestCommands.size(); ++i)
     {
     command = ctestCommands[i];
     output = "";
     retVal = 0;
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Run ctest command: "
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run ctest command: "
       << command.c_str() << std::endl);
     res = cmSystemTools::RunSingleCommand(command.c_str(), &output,
-                                          &retVal, m_BinaryDir.c_str(),
-                                          m_HandlerVerbose, 0 /*m_TimeOut*/);
+      &retVal, this->BinaryDir.c_str(), this->HandlerVerbose,
+      0 /*this->TimeOut*/);
 
     // did something critical fail in ctest
     if (!res || cmakeFailed ||
@@ -780,11 +796,13 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
       this->RestoreBackupDirectories();
       if (cmakeFailed)
         {
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "Unable to run cmake:" << std::endl
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+          "Unable to run cmake:" << std::endl
           << cmakeFailedOuput.c_str() << std::endl);
         return 10;
         }
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "Unable to run ctest:" << std::endl
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+        "Unable to run ctest:" << std::endl
         << output.c_str() << std::endl);
       if (!res)
         {
@@ -795,10 +813,10 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
     }
 
   // if all was succesful, delete the backup dirs to free up disk space
-  if (m_Backup)
+  if (this->Backup)
     {
-    cmSystemTools::RemoveADirectory(m_BackupSourceDir.c_str());
-    cmSystemTools::RemoveADirectory(m_BackupBinaryDir.c_str());
+    cmSystemTools::RemoveADirectory(this->BackupSourceDir.c_str());
+    cmSystemTools::RemoveADirectory(this->BackupBinaryDir.c_str());
     }
 
   return 0;
@@ -810,20 +828,20 @@ void cmCTestScriptHandler::RestoreBackupDirectories()
 {
   // if we backed up the dirs and the build failed, then restore
   // the backed up dirs
-  if (m_Backup)
+  if (this->Backup)
     {
     // if for some reason those directories exist then first delete them
-    if (cmSystemTools::FileExists(m_SourceDir.c_str()))
+    if (cmSystemTools::FileExists(this->SourceDir.c_str()))
       {
-      cmSystemTools::RemoveADirectory(m_SourceDir.c_str());
+      cmSystemTools::RemoveADirectory(this->SourceDir.c_str());
       }
-    if (cmSystemTools::FileExists(m_BinaryDir.c_str()))
+    if (cmSystemTools::FileExists(this->BinaryDir.c_str()))
       {
-      cmSystemTools::RemoveADirectory(m_BinaryDir.c_str());
+      cmSystemTools::RemoveADirectory(this->BinaryDir.c_str());
       }
     // rename the src and binary directories
-    rename(m_BackupSourceDir.c_str(), m_SourceDir.c_str());
-    rename(m_BackupBinaryDir.c_str(), m_BinaryDir.c_str());
+    rename(this->BackupSourceDir.c_str(), this->SourceDir.c_str());
+    rename(this->BackupBinaryDir.c_str(), this->BinaryDir.c_str());
     }
 }
 
diff --git a/Source/CTest/cmCTestScriptHandler.h b/Source/CTest/cmCTestScriptHandler.h
index 89880ab..344192b 100644
--- a/Source/CTest/cmCTestScriptHandler.h
+++ b/Source/CTest/cmCTestScriptHandler.h
@@ -9,8 +9,8 @@
   Copyright (c) 2002 Kitware, Inc. All rights reserved.
   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
 
-     This software is distributed WITHOUT ANY WARRANTY; without even 
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
      PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
@@ -50,7 +50,7 @@ class cmCTestCommand;
  *   CTEST_INITIAL_CACHE
  *   CTEST_START_WITH_EMPTY_BINARY_DIRECTORY
  *   CTEST_START_WITH_EMPTY_BINARY_DIRECTORY_ONCE
- *   
+ *
  * In addition the following variables can be used. The number can be 1-10.
  *   CTEST_EXTRA_UPDATES_1
  *   CTEST_EXTRA_UPDATES_2
@@ -83,7 +83,7 @@ public:
    */
   static bool RunScript(cmCTest* ctest, const char *script);
   int RunCurrentScript();
-    
+
   /*
    * Empty Binary Directory
    */
@@ -97,7 +97,7 @@ public:
 
   cmCTestScriptHandler();
   ~cmCTestScriptHandler();
-  
+
   void Initialize();
 private:
   // reads in a script
@@ -111,7 +111,7 @@ private:
 
   // perform any extra cvs updates that were requested
   int PerformExtraUpdates();
-  
+
   // backup and restore dirs
   int BackupDirectories();
   void RestoreBackupDirectories();
@@ -122,36 +122,36 @@ private:
   // Add ctest command
   void AddCTestCommand(cmCTestCommand* command);
 
-  std::vector<cmStdString> m_ConfigurationScripts;
-
-  bool m_Backup;
-  bool m_EmptyBinDir;
-  bool m_EmptyBinDirOnce;
-  
-  cmStdString m_SourceDir;
-  cmStdString m_BinaryDir;
-  cmStdString m_BackupSourceDir;
-  cmStdString m_BackupBinaryDir;
-  cmStdString m_CTestRoot;
-  cmStdString m_CVSCheckOut;
-  cmStdString m_CTestCmd;
-  cmStdString m_CVSCmd;
-  cmStdString m_CTestEnv;
-  cmStdString m_InitCache;
-  cmStdString m_CMakeCmd;
-  cmStdString m_CMOutFile;
-  std::vector<cmStdString> m_ExtraUpdates;
-
-  double m_MinimumInterval;
-  double m_ContinuousDuration;
+  std::vector<cmStdString> ConfigurationScripts;
+
+  bool Backup;
+  bool EmptyBinDir;
+  bool EmptyBinDirOnce;
+
+  cmStdString SourceDir;
+  cmStdString BinaryDir;
+  cmStdString BackupSourceDir;
+  cmStdString BackupBinaryDir;
+  cmStdString CTestRoot;
+  cmStdString CVSCheckOut;
+  cmStdString CTestCmd;
+  cmStdString CVSCmd;
+  cmStdString CTestEnv;
+  cmStdString InitCache;
+  cmStdString CMakeCmd;
+  cmStdString CMOutFile;
+  std::vector<cmStdString> ExtraUpdates;
+
+  double MinimumInterval;
+  double ContinuousDuration;
 
   // what time in seconds did this script start running
-  double m_ScriptStartTime;
-  
-  cmMakefile *m_Makefile;
-  cmLocalGenerator *m_LocalGenerator;
-  cmGlobalGenerator *m_GlobalGenerator;
-  cmake *m_CMake;
+  double ScriptStartTime;
+
+  cmMakefile *Makefile;
+  cmLocalGenerator *LocalGenerator;
+  cmGlobalGenerator *GlobalGenerator;
+  cmake *CMake;
 };
 
 #endif
diff --git a/Source/CTest/cmCTestSleepCommand.cxx b/Source/CTest/cmCTestSleepCommand.cxx
index d3f0c6f..11108e8 100644
--- a/Source/CTest/cmCTestSleepCommand.cxx
+++ b/Source/CTest/cmCTestSleepCommand.cxx
@@ -34,7 +34,7 @@ bool cmCTestSleepCommand::InitialPass(
     {
     cmCTestScriptHandler::SleepInSeconds(time1);
     // update the elapsed time since it could have slept for a while
-    m_CTestScriptHandler->UpdateElapsedTime();
+    this->CTestScriptHandler->UpdateElapsedTime();
     return true;
     }
 
@@ -48,7 +48,7 @@ bool cmCTestSleepCommand::InitialPass(
       duration = (time1 + duration - time2);
       cmCTestScriptHandler::SleepInSeconds(duration);
       // update the elapsed time since it could have slept for a while
-      m_CTestScriptHandler->UpdateElapsedTime();
+      this->CTestScriptHandler->UpdateElapsedTime();
       }
     return true;
     }
diff --git a/Source/CTest/cmCTestSleepCommand.h b/Source/CTest/cmCTestSleepCommand.h
index f119a43..37a6c88 100644
--- a/Source/CTest/cmCTestSleepCommand.h
+++ b/Source/CTest/cmCTestSleepCommand.h
@@ -37,8 +37,8 @@ public:
   virtual cmCommand* Clone() 
     {
     cmCTestSleepCommand* ni = new cmCTestSleepCommand;
-    ni->m_CTest = this->m_CTest;
-    ni->m_CTestScriptHandler = this->m_CTestScriptHandler;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
     }
 
diff --git a/Source/CTest/cmCTestStartCommand.cxx b/Source/CTest/cmCTestStartCommand.cxx
index 1160805..38b5cd7 100644
--- a/Source/CTest/cmCTestStartCommand.cxx
+++ b/Source/CTest/cmCTestStartCommand.cxx
@@ -66,22 +66,22 @@ bool cmCTestStartCommand::InitialPass(
       "as an argument or set CTEST_BINARY_DIRECTORY");
     return false;
     }
-  m_CTest->EmptyCTestConfiguration();
-  m_CTest->SetCTestConfiguration("SourceDirectory", src_dir);
-  m_CTest->SetCTestConfiguration("BuildDirectory", bld_dir);
+  this->CTest->EmptyCTestConfiguration();
+  this->CTest->SetCTestConfiguration("SourceDirectory", src_dir);
+  this->CTest->SetCTestConfiguration("BuildDirectory", bld_dir);
 
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "Run dashboard with model " << smodel
-    << std::endl
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "Run dashboard with model "
+    << smodel << std::endl
     << "   Source directory: " << src_dir << std::endl
     << "   Build directory: " << bld_dir << std::endl);
 
   m_Makefile->AddDefinition("CTEST_RUN_CURRENT_SCRIPT", "OFF");
-  m_CTest->SetSuppressUpdatingCTestConfiguration(true);
-  int model = m_CTest->GetTestModelFromString(smodel);
-  m_CTest->SetTestModel(model);
-  m_CTest->SetProduceXML(true);
+  this->CTest->SetSuppressUpdatingCTestConfiguration(true);
+  int model = this->CTest->GetTestModelFromString(smodel);
+  this->CTest->SetTestModel(model);
+  this->CTest->SetProduceXML(true);
 
-  return m_CTest->InitializeFromCommand(this, true);
+  return this->CTest->InitializeFromCommand(this, true);
 }
 
 
diff --git a/Source/CTest/cmCTestStartCommand.h b/Source/CTest/cmCTestStartCommand.h
index 3e81d33..f651bc8 100644
--- a/Source/CTest/cmCTestStartCommand.h
+++ b/Source/CTest/cmCTestStartCommand.h
@@ -36,8 +36,8 @@ public:
   virtual cmCommand* Clone()
     {
     cmCTestStartCommand* ni = new cmCTestStartCommand;
-    ni->m_CTest = this->m_CTest;
-    ni->m_CTestScriptHandler = this->m_CTestScriptHandler;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
     }
 
diff --git a/Source/CTest/cmCTestSubmitCommand.cxx b/Source/CTest/cmCTestSubmitCommand.cxx
index bfa0edb..e28522e 100644
--- a/Source/CTest/cmCTestSubmitCommand.cxx
+++ b/Source/CTest/cmCTestSubmitCommand.cxx
@@ -77,20 +77,20 @@ bool cmCTestSubmitCommand::InitialPass(
     {
     ctestTriggerSite
       = "http://public.kitware.com/cgi-bin/Submit-Random-TestingResults.cgi";
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "* Use default trigger site: "
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "* Use default trigger site: "
       << ctestTriggerSite << std::endl;);
     }
 
-  m_CTest->SetCTestConfiguration("DropMethod",   ctestDropMethod);
-  m_CTest->SetCTestConfiguration("DropSite",     ctestDropSite);
-  m_CTest->SetCTestConfiguration("DropLocation", ctestDropLocation);
-  m_CTest->SetCTestConfiguration("TriggerSite",  ctestTriggerSite);
+  this->CTest->SetCTestConfiguration("DropMethod",   ctestDropMethod);
+  this->CTest->SetCTestConfiguration("DropSite",     ctestDropSite);
+  this->CTest->SetCTestConfiguration("DropLocation", ctestDropLocation);
+  this->CTest->SetCTestConfiguration("TriggerSite",  ctestTriggerSite);
 
-  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
     "DropSiteUser", "CTEST_DROP_SITE_USER");
-  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
     "DropSitePassword", "CTEST_DROP_SITE_PASSWORD");
-  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
     "ScpCommand", "CTEST_SCP_COMMAND");
 
   const char* notesFilesVariable
@@ -107,7 +107,7 @@ bool cmCTestSubmitCommand::InitialPass(
       {
       newNotesFiles.push_back(*it);
       }
-    m_CTest->GenerateNotesFile(newNotesFiles);
+    this->CTest->GenerateNotesFile(newNotesFiles);
     }
   const char* extraFilesVariable
     = m_Makefile->GetDefinition("CTEST_EXTRA_SUBMIT_FILES");
@@ -123,14 +123,15 @@ bool cmCTestSubmitCommand::InitialPass(
       {
       newExtraFiles.push_back(*it);
       }
-    if ( !m_CTest->SubmitExtraFiles(newExtraFiles))
+    if ( !this->CTest->SubmitExtraFiles(newExtraFiles))
       {
       this->SetError("problem submitting extra files.");
       return false;
       }
     }
 
-  cmCTestGenericHandler* handler = m_CTest->GetInitializedHandler("submit");
+  cmCTestGenericHandler* handler
+    = this->CTest->GetInitializedHandler("submit");
   if ( !handler )
     {
     this->SetError("internal CTest error. Cannot instantiate submit handler");
diff --git a/Source/CTest/cmCTestSubmitCommand.h b/Source/CTest/cmCTestSubmitCommand.h
index 843c652..a683781 100644
--- a/Source/CTest/cmCTestSubmitCommand.h
+++ b/Source/CTest/cmCTestSubmitCommand.h
@@ -37,8 +37,8 @@ public:
   virtual cmCommand* Clone()
     {
     cmCTestSubmitCommand* ni = new cmCTestSubmitCommand;
-    ni->m_CTest = this->m_CTest;
-    ni->m_CTestScriptHandler = this->m_CTestScriptHandler;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
     }
 
diff --git a/Source/CTest/cmCTestSubmitHandler.cxx b/Source/CTest/cmCTestSubmitHandler.cxx
index 4f71b6b..2524f16 100644
--- a/Source/CTest/cmCTestSubmitHandler.cxx
+++ b/Source/CTest/cmCTestSubmitHandler.cxx
@@ -61,26 +61,26 @@ cmCTestSubmitHandlerCurlDebugCallback(CURL *, curl_infotype, char *chPtr,
 }
 
 //----------------------------------------------------------------------------
-cmCTestSubmitHandler::cmCTestSubmitHandler() : m_HTTPProxy(), m_FTPProxy()
+cmCTestSubmitHandler::cmCTestSubmitHandler() : HTTPProxy(), FTPProxy()
 {
-  m_HTTPProxy = "";
-  m_HTTPProxyType = 0;
-  m_HTTPProxyAuth = "";
+  this->HTTPProxy = "";
+  this->HTTPProxyType = 0;
+  this->HTTPProxyAuth = "";
 
-  m_FTPProxy = "";
-  m_FTPProxyType = 0;
+  this->FTPProxy = "";
+  this->FTPProxyType = 0;
 }
 
 //----------------------------------------------------------------------------
 void cmCTestSubmitHandler::Initialize()
 {
   this->Superclass::Initialize();
-  m_HTTPProxy = "";
-  m_HTTPProxyType = 0;
-  m_HTTPProxyAuth = "";
-  m_FTPProxy = "";
-  m_FTPProxyType = 0;
-  m_LogFile = 0;
+  this->HTTPProxy = "";
+  this->HTTPProxyType = 0;
+  this->HTTPProxyAuth = "";
+  this->FTPProxy = "";
+  this->FTPProxyType = 0;
+  this->LogFile = 0;
 }
 
 //----------------------------------------------------------------------------
@@ -97,7 +97,7 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
   /* In windows, this will init the winsock stuff */
   ::curl_global_init(CURL_GLOBAL_ALL);
 
-  cmCTest::tm_SetOfStrings::const_iterator file;
+  cmCTest::SetOfStrings::const_iterator file;
   for ( file = files.begin(); file != files.end(); ++file )
     {
     /* get a curl handle */
@@ -105,10 +105,10 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
     if(curl)
       {
       // Using proxy
-      if ( m_FTPProxyType > 0 )
+      if ( this->FTPProxyType > 0 )
         {
-        curl_easy_setopt(curl, CURLOPT_PROXY, m_FTPProxy.c_str());
-        switch (m_FTPProxyType)
+        curl_easy_setopt(curl, CURLOPT_PROXY, this->FTPProxy.c_str());
+        switch (this->FTPProxyType)
           {
         case 2:
           curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
@@ -135,7 +135,7 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
       struct stat st;
       if ( ::stat(local_file.c_str(), &st) )
         {
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "   Cannot find file: "
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Cannot find file: "
           << local_file.c_str() << std::endl);
         ::curl_easy_cleanup(curl);
         ::curl_global_cleanup();
@@ -143,9 +143,9 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
         }
 
       ftpfile = ::fopen(local_file.c_str(), "rb");
-      *m_LogFile << "\tUpload file: " << local_file.c_str() << " to "
+      *this->LogFile << "\tUpload file: " << local_file.c_str() << " to "
           << upload_as.c_str() << std::endl;
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "   Upload file: "
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "   Upload file: "
         << local_file.c_str() << " to "
         << upload_as.c_str() << std::endl);
 
@@ -181,13 +181,13 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
 
       if ( chunk.size() > 0 )
         {
-        cmCTestLog(m_CTest, DEBUG, "CURL output: ["
+        cmCTestLog(this->CTest, DEBUG, "CURL output: ["
           << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
           << std::endl);
         }
       if ( chunkDebug.size() > 0 )
         {
-        cmCTestLog(m_CTest, DEBUG, "CURL debug output: ["
+        cmCTestLog(this->CTest, DEBUG, "CURL debug output: ["
           << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
           << std::endl);
         }
@@ -195,16 +195,18 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
       fclose(ftpfile);
       if ( res )
         {
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "   Error when uploading file: "
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+          "   Error when uploading file: "
           << local_file.c_str() << std::endl);
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "   Error message was: "
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error message was: "
           << error_buffer << std::endl);
-        *m_LogFile << "   Error when uploading file: " << local_file.c_str()
+        *this->LogFile << "   Error when uploading file: "
+          << local_file.c_str()
           << std::endl
           << "   Error message was: " << error_buffer << std::endl
           << "   Curl output was: "
           << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << std::endl;
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "CURL output: ["
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
           << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
           << std::endl);
         ::curl_easy_cleanup(curl);
@@ -213,7 +215,7 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
         }
       // always cleanup
       ::curl_easy_cleanup(curl);
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Uploaded: " + local_file
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Uploaded: " + local_file
         << std::endl);
       }
     }
@@ -237,7 +239,7 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
   ::curl_global_init(CURL_GLOBAL_ALL);
 
   cmStdString::size_type kk;
-  cmCTest::tm_SetOfStrings::const_iterator file;
+  cmCTest::SetOfStrings::const_iterator file;
   for ( file = files.begin(); file != files.end(); ++file )
     {
     /* get a curl handle */
@@ -246,10 +248,10 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
       {
 
       // Using proxy
-      if ( m_HTTPProxyType > 0 )
+      if ( this->HTTPProxyType > 0 )
         {
-        curl_easy_setopt(curl, CURLOPT_PROXY, m_HTTPProxy.c_str());
-        switch (m_HTTPProxyType)
+        curl_easy_setopt(curl, CURLOPT_PROXY, this->HTTPProxy.c_str());
+        switch (this->HTTPProxyType)
           {
         case 2:
           curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
@@ -259,10 +261,10 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
           break;
         default:
           curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
-          if (m_HTTPProxyAuth.size() > 0)
+          if (this->HTTPProxyAuth.size() > 0)
             {
             curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD,
-              m_HTTPProxyAuth.c_str());
+              this->HTTPProxyAuth.c_str());
             }
           }
         }
@@ -282,7 +284,7 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
       cmStdString remote_file
         = remoteprefix + cmSystemTools::GetFilenameName(*file);
 
-      *m_LogFile << "\tUpload file: " << local_file.c_str() << " to "
+      *this->LogFile << "\tUpload file: " << local_file.c_str() << " to "
           << remote_file.c_str() << std::endl;
 
       cmStdString ofile = "";
@@ -315,7 +317,7 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
       struct stat st;
       if ( ::stat(local_file.c_str(), &st) )
         {
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "   Cannot find file: "
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Cannot find file: "
           << local_file.c_str() << std::endl);
         ::curl_easy_cleanup(curl);
         ::curl_global_cleanup();
@@ -323,7 +325,7 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
         }
 
       ftpfile = ::fopen(local_file.c_str(), "rb");
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "   Upload file: "
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "   Upload file: "
         << local_file.c_str() << " to "
         << upload_as.c_str() << " Size: " << st.st_size << std::endl);
 
@@ -358,13 +360,13 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
 
       if ( chunk.size() > 0 )
         {
-        cmCTestLog(m_CTest, DEBUG, "CURL output: ["
+        cmCTestLog(this->CTest, DEBUG, "CURL output: ["
           << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
           << std::endl);
         }
       if ( chunkDebug.size() > 0 )
         {
-        cmCTestLog(m_CTest, DEBUG, "CURL debug output: ["
+        cmCTestLog(this->CTest, DEBUG, "CURL debug output: ["
           << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
           << std::endl);
         }
@@ -372,16 +374,18 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
       fclose(ftpfile);
       if ( res )
         {
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "   Error when uploading file: "
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+          "   Error when uploading file: "
           << local_file.c_str() << std::endl);
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "   Error message was: "
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error message was: "
           << error_buffer << std::endl);
-        *m_LogFile << "   Error when uploading file: " << local_file.c_str()
+        *this->LogFile << "   Error when uploading file: "
+          << local_file.c_str()
           << std::endl
           << "   Error message was: " << error_buffer << std::endl
           << "   Curl output was: "
           << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << std::endl;
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "CURL output: ["
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
           << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
           << std::endl);
         ::curl_easy_cleanup(curl);
@@ -390,7 +394,7 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
         }
       // always cleanup
       ::curl_easy_cleanup(curl);
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Uploaded: " + local_file
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Uploaded: " + local_file
         << std::endl);
       }
     }
@@ -410,7 +414,7 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(
   /* In windows, this will init the winsock stuff */
   ::curl_global_init(CURL_GLOBAL_ALL);
 
-  cmCTest::tm_SetOfStrings::const_iterator file;
+  cmCTest::SetOfStrings::const_iterator file;
   for ( file = files.begin(); file != files.end(); ++file )
     {
     /* get a curl handle */
@@ -418,10 +422,10 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(
     if(curl)
       {
       // Using proxy
-      if ( m_HTTPProxyType > 0 )
+      if ( this->HTTPProxyType > 0 )
         {
-        curl_easy_setopt(curl, CURLOPT_PROXY, m_HTTPProxy.c_str());
-        switch (m_HTTPProxyType)
+        curl_easy_setopt(curl, CURLOPT_PROXY, this->HTTPProxy.c_str());
+        switch (this->HTTPProxyType)
           {
         case 2:
           curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
@@ -431,10 +435,10 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(
           break;
         default:
           curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
-          if (m_HTTPProxyAuth.size() > 0)
+          if (this->HTTPProxyAuth.size() > 0)
             {
             curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD,
-              m_HTTPProxyAuth.c_str());
+              this->HTTPProxyAuth.c_str());
             }
           }
         }
@@ -485,22 +489,22 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(
       cmStdString turl
         = url + ((url.find("?",0) == cmStdString::npos) ? "?" : "&")
         + "xmlfile=" + ofile;
-      *m_LogFile << "Trigger url: " << turl.c_str() << std::endl;
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "   Trigger url: "
+      *this->LogFile << "Trigger url: " << turl.c_str() << std::endl;
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "   Trigger url: "
         << turl.c_str() << std::endl);
       curl_easy_setopt(curl, CURLOPT_URL, turl.c_str());
       if ( curl_easy_perform(curl) )
         {
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "   Error when triggering: "
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error when triggering: "
           << turl.c_str() << std::endl);
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "   Error message was: "
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error message was: "
           << error_buffer << std::endl);
-        *m_LogFile << "\tTrigerring failed with error: " << error_buffer
+        *this->LogFile << "\tTrigerring failed with error: " << error_buffer
           << std::endl
           << "   Error message was: " << error_buffer << std::endl
           << "   Curl output was: "
           << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << std::endl;
-        cmCTestLog(m_CTest, ERROR_MESSAGE, "CURL output: ["
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
           << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
           << std::endl);
         ::curl_easy_cleanup(curl);
@@ -510,24 +514,24 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(
 
       if ( chunk.size() > 0 )
         {
-        cmCTestLog(m_CTest, DEBUG, "CURL output: ["
+        cmCTestLog(this->CTest, DEBUG, "CURL output: ["
           << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
           << std::endl);
         }
       if ( chunkDebug.size() > 0 )
         {
-        cmCTestLog(m_CTest, DEBUG, "CURL debug output: ["
+        cmCTestLog(this->CTest, DEBUG, "CURL debug output: ["
           << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size())
           << "]" << std::endl);
         }
 
       // always cleanup
       ::curl_easy_cleanup(curl);
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, std::endl);
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl);
       }
     }
   ::curl_global_cleanup();
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Dart server triggered..."
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Dart server triggered..."
     << std::endl);
   return true;
 }
@@ -557,7 +561,7 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(
 
   int problems = 0;
 
-  cmCTest::tm_SetOfStrings::const_iterator file;
+  cmCTest::SetOfStrings::const_iterator file;
   for ( file = files.begin(); file != files.end(); ++file )
     {
     int retVal;
@@ -569,10 +573,10 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(
     argv[1] = lfname.c_str();
     std::string rfname = url + "/" + remoteprefix + *file;
     argv[2] = rfname.c_str();
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Execute \"" << argv[0]
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Execute \"" << argv[0]
       << "\" \"" << argv[1] << "\" \""
       << argv[2] << "\"" << std::endl);
-    *m_LogFile << "Execute \"" << argv[0] << "\" \"" << argv[1] << "\" \""
+    *this->LogFile << "Execute \"" << argv[0] << "\" \"" << argv[1] << "\" \""
       << argv[2] << "\"" << std::endl;
 
     cmsysProcess_SetCommand(cp, &*argv.begin());
@@ -582,7 +586,7 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(
 
     while(cmsysProcess_WaitForData(cp, &data, &length, 0))
       {
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT,
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
         cmCTestLogWrite(data, length));
       }
 
@@ -595,32 +599,32 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(
       retVal = cmsysProcess_GetExitValue(cp);
       if ( retVal != 0 )
         {
-        cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "\tSCP returned: "
+        cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "\tSCP returned: "
           << retVal << std::endl);
-        *m_LogFile << "\tSCP returned: " << retVal << std::endl;
+        *this->LogFile << "\tSCP returned: " << retVal << std::endl;
         problems ++;
         }
       }
     else if(result == cmsysProcess_State_Exception)
       {
       retVal = cmsysProcess_GetExitException(cp);
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "\tThere was an exception: "
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "\tThere was an exception: "
         << retVal << std::endl);
-      *m_LogFile << "\tThere was an exception: " << retVal << std::endl;
+      *this->LogFile << "\tThere was an exception: " << retVal << std::endl;
       problems ++;
       }
     else if(result == cmsysProcess_State_Expired)
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "\tThere was a timeout"
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "\tThere was a timeout"
         << std::endl);
-      *m_LogFile << "\tThere was a timeout" << std::endl;
+      *this->LogFile << "\tThere was a timeout" << std::endl;
       problems ++;
       }
     else if(result == cmsysProcess_State_Error)
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "\tError executing SCP: "
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "\tError executing SCP: "
         << cmsysProcess_GetErrorString(cp) << std::endl);
-      *m_LogFile << "\tError executing SCP: "
+      *this->LogFile << "\tError executing SCP: "
         << cmsysProcess_GetErrorString(cp) << std::endl;
       problems ++;
       }
@@ -651,9 +655,9 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
   xmlrpc_env_init(&env);
 
   /* Call the famous server at UserLand. */
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Submitting to: "
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Submitting to: "
     << realURL.c_str() << " (" << remoteprefix.c_str() << ")" << std::endl);
-  cmCTest::tm_SetOfStrings::const_iterator file;
+  cmCTest::SetOfStrings::const_iterator file;
   for ( file = files.begin(); file != files.end(); ++file )
     {
     xmlrpc_value *result;
@@ -663,12 +667,12 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
       {
       local_file = localprefix + "/" + *file;
       }
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Submit file: "
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Submit file: "
       << local_file.c_str() << std::endl);
     struct stat st;
     if ( ::stat(local_file.c_str(), &st) )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "  Cannot find file: "
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "  Cannot find file: "
         << local_file.c_str() << std::endl);
       return false;
       }
@@ -677,7 +681,7 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
     FILE* fp = fopen(local_file.c_str(), "rb");
     if ( !fp )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "  Cannot open file: "
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "  Cannot open file: "
         << local_file.c_str() << std::endl);
       return false;
       }
@@ -687,7 +691,7 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
       {
       delete [] fileBuffer;
       fclose(fp);
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "  Cannot read file: "
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "  Cannot read file: "
         << local_file.c_str() << std::endl);
       return false;
       }
@@ -702,7 +706,7 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
 
     if ( env.fault_occurred )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, " Submission problem: "
+      cmCTestLog(this->CTest, ERROR_MESSAGE, " Submission problem: "
         << env.fault_string << " (" << env.fault_code << ")" << std::endl);
       xmlrpc_env_clean(&env);
       xmlrpc_client_cleanup();
@@ -725,10 +729,10 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
 int cmCTestSubmitHandler::ProcessHandler()
 {
   const std::string &buildDirectory
-    = m_CTest->GetCTestConfiguration("BuildDirectory");
+    = this->CTest->GetCTestConfiguration("BuildDirectory");
   if ( buildDirectory.size() == 0 )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE,
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
       "Cannot find BuildDirectory  key in the DartConfiguration.tcl"
       << std::endl);
     return -1;
@@ -736,12 +740,12 @@ int cmCTestSubmitHandler::ProcessHandler()
 
   if ( getenv("HTTP_PROXY") )
     {
-    m_HTTPProxyType = 1;
-    m_HTTPProxy = getenv("HTTP_PROXY");
+    this->HTTPProxyType = 1;
+    this->HTTPProxy = getenv("HTTP_PROXY");
     if ( getenv("HTTP_PROXY_PORT") )
       {
-      m_HTTPProxy += ":";
-      m_HTTPProxy += getenv("HTTP_PROXY_PORT");
+      this->HTTPProxy += ":";
+      this->HTTPProxy += getenv("HTTP_PROXY_PORT");
       }
     if ( getenv("HTTP_PROXY_TYPE") )
       {
@@ -749,36 +753,36 @@ int cmCTestSubmitHandler::ProcessHandler()
       // HTTP/SOCKS4/SOCKS5
       if ( type == "HTTP" )
         {
-        m_HTTPProxyType = 1;
+        this->HTTPProxyType = 1;
         }
       else if ( type == "SOCKS4" )
         {
-        m_HTTPProxyType = 2;
+        this->HTTPProxyType = 2;
         }
       else if ( type == "SOCKS5" )
         {
-        m_HTTPProxyType = 3;
+        this->HTTPProxyType = 3;
         }
       }
     if ( getenv("HTTP_PROXY_USER") )
       {
-      m_HTTPProxyAuth = getenv("HTTP_PROXY_USER");
+      this->HTTPProxyAuth = getenv("HTTP_PROXY_USER");
       }
     if ( getenv("HTTP_PROXY_PASSWD") )
       {
-      m_HTTPProxyAuth += ":";
-      m_HTTPProxyAuth += getenv("HTTP_PROXY_PASSWD");
+      this->HTTPProxyAuth += ":";
+      this->HTTPProxyAuth += getenv("HTTP_PROXY_PASSWD");
       }
     }
 
   if ( getenv("FTP_PROXY") )
     {
-    m_FTPProxyType = 1;
-    m_FTPProxy = getenv("FTP_PROXY");
+    this->FTPProxyType = 1;
+    this->FTPProxy = getenv("FTP_PROXY");
     if ( getenv("FTP_PROXY_PORT") )
       {
-      m_FTPProxy += ":";
-      m_FTPProxy += getenv("FTP_PROXY_PORT");
+      this->FTPProxy += ":";
+      this->FTPProxy += getenv("FTP_PROXY_PORT");
       }
     if ( getenv("FTP_PROXY_TYPE") )
       {
@@ -786,48 +790,48 @@ int cmCTestSubmitHandler::ProcessHandler()
       // HTTP/SOCKS4/SOCKS5
       if ( type == "HTTP" )
         {
-        m_FTPProxyType = 1;
+        this->FTPProxyType = 1;
         }
       else if ( type == "SOCKS4" )
         {
-        m_FTPProxyType = 2;
+        this->FTPProxyType = 2;
         }
       else if ( type == "SOCKS5" )
         {
-        m_FTPProxyType = 3;
+        this->FTPProxyType = 3;
         }
       }
     }
 
-  if ( m_HTTPProxy.size() > 0 )
+  if ( this->HTTPProxy.size() > 0 )
     {
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Use HTTP Proxy: " << m_HTTPProxy
-      << std::endl);
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Use HTTP Proxy: "
+      << this->HTTPProxy << std::endl);
     }
-  if ( m_FTPProxy.size() > 0 )
+  if ( this->FTPProxy.size() > 0 )
     {
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Use FTP Proxy: " << m_FTPProxy
-      << std::endl);
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Use FTP Proxy: "
+      << this->FTPProxy << std::endl);
     }
   cmGeneratedFileStream ofs;
   this->StartLogFile("Submit", ofs);
 
-  cmCTest::tm_SetOfStrings files;
+  cmCTest::SetOfStrings files;
   std::string prefix = this->GetSubmitResultsPrefix();
   // TODO:
   // Check if test is enabled
-  m_CTest->AddIfExists(files, "Update.xml");
-  m_CTest->AddIfExists(files, "Configure.xml");
-  m_CTest->AddIfExists(files, "Build.xml");
-  m_CTest->AddIfExists(files, "Test.xml");
-  if ( m_CTest->AddIfExists(files, "Coverage.xml") )
+  this->CTest->AddIfExists(files, "Update.xml");
+  this->CTest->AddIfExists(files, "Configure.xml");
+  this->CTest->AddIfExists(files, "Build.xml");
+  this->CTest->AddIfExists(files, "Test.xml");
+  if ( this->CTest->AddIfExists(files, "Coverage.xml") )
     {
-    cmCTest::tm_VectorOfStrings gfiles;
+    cmCTest::VectorOfStrings gfiles;
     std::string gpath
-      = buildDirectory + "/Testing/" + m_CTest->GetCurrentTag();
+      = buildDirectory + "/Testing/" + this->CTest->GetCurrentTag();
     std::string::size_type glen = gpath.size() + 1;
     gpath = gpath + "/CoverageLog*";
-    cmCTestLog(m_CTest, DEBUG, "Globbing for: " << gpath.c_str()
+    cmCTestLog(this->CTest, DEBUG, "Globbing for: " << gpath.c_str()
       << std::endl);
     if ( cmSystemTools::SimpleGlob(gpath, gfiles, 1) )
       {
@@ -835,23 +839,23 @@ int cmCTestSubmitHandler::ProcessHandler()
       for ( cc = 0; cc < gfiles.size(); cc ++ )
         {
         gfiles[cc] = gfiles[cc].substr(glen);
-        cmCTestLog(m_CTest, DEBUG, "Glob file: " << gfiles[cc].c_str()
+        cmCTestLog(this->CTest, DEBUG, "Glob file: " << gfiles[cc].c_str()
           << std::endl);
         files.insert(gfiles[cc]);
         }
       }
     else
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "Problem globbing" << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Problem globbing" << std::endl);
       }
     }
-  m_CTest->AddIfExists(files, "DynamicAnalysis.xml");
-  m_CTest->AddIfExists(files, "Purify.xml");
-  m_CTest->AddIfExists(files, "Notes.xml");
+  this->CTest->AddIfExists(files, "DynamicAnalysis.xml");
+  this->CTest->AddIfExists(files, "Purify.xml");
+  this->CTest->AddIfExists(files, "Notes.xml");
 
-  cmCTest::tm_SetOfStrings::iterator it;
-  for ( it = m_CTest->GetSubmitFiles()->begin();
-   it != m_CTest->GetSubmitFiles()->end();
+  cmCTest::SetOfStrings::iterator it;
+  for ( it = this->CTest->GetSubmitFiles()->begin();
+   it != this->CTest->GetSubmitFiles()->end();
    ++ it )
     {
     files.insert(files.end(), *it);
@@ -867,177 +871,184 @@ int cmCTestSubmitHandler::ProcessHandler()
       cnt ++;
       }
     }
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "Submit files (using "
-    << m_CTest->GetCTestConfiguration("DropMethod") << ")"
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "Submit files (using "
+    << this->CTest->GetCTestConfiguration("DropMethod") << ")"
     << std::endl);
   this->SetLogFile(&ofs);
-  if ( m_CTest->GetCTestConfiguration("DropMethod") == "" ||
-    m_CTest->GetCTestConfiguration("DropMethod") ==  "ftp" )
+  if ( this->CTest->GetCTestConfiguration("DropMethod") == "" ||
+    this->CTest->GetCTestConfiguration("DropMethod") ==  "ftp" )
     {
     ofs << "Using drop method: FTP" << std::endl;
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Using FTP submit method"
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Using FTP submit method"
       << std::endl
       << "   Drop site: ftp://");
     std::string url = "ftp://";
     url += cmCTest::MakeURLSafe(
-      m_CTest->GetCTestConfiguration("DropSiteUser")) + ":" +
-      cmCTest::MakeURLSafe(m_CTest->GetCTestConfiguration(
+      this->CTest->GetCTestConfiguration("DropSiteUser")) + ":" +
+      cmCTest::MakeURLSafe(this->CTest->GetCTestConfiguration(
           "DropSitePassword")) + "@" +
-      m_CTest->GetCTestConfiguration("DropSite") +
-      cmCTest::MakeURLSafe(m_CTest->GetCTestConfiguration("DropLocation"));
-    if ( m_CTest->GetCTestConfiguration("DropSiteUser").size() > 0 )
+      this->CTest->GetCTestConfiguration("DropSite") +
+      cmCTest::MakeURLSafe(
+        this->CTest->GetCTestConfiguration("DropLocation"));
+    if ( this->CTest->GetCTestConfiguration("DropSiteUser").size() > 0 )
       {
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, m_CTest->GetCTestConfiguration(
+      cmCTestLog(this->CTest, HANDLER_OUTPUT,
+        this->CTest->GetCTestConfiguration(
           "DropSiteUser").c_str());
-      if ( m_CTest->GetCTestConfiguration("DropSitePassword").size() > 0 )
+      if ( this->CTest->GetCTestConfiguration("DropSitePassword").size() > 0 )
         {
-        cmCTestLog(m_CTest, HANDLER_OUTPUT, ":******");
+        cmCTestLog(this->CTest, HANDLER_OUTPUT, ":******");
         }
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, "@");
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "@");
       }
-    cmCTestLog(m_CTest, HANDLER_OUTPUT,
-      m_CTest->GetCTestConfiguration("DropSite")
-      << m_CTest->GetCTestConfiguration("DropLocation") << std::endl);
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+      this->CTest->GetCTestConfiguration("DropSite")
+      << this->CTest->GetCTestConfiguration("DropLocation") << std::endl);
     if ( !this->SubmitUsingFTP(buildDirectory + "/Testing/"
-        + m_CTest->GetCurrentTag(),
+        + this->CTest->GetCurrentTag(),
         files, prefix, url) )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "   Problems when submitting via FTP"
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+        "   Problems when submitting via FTP"
         << std::endl);
       ofs << "   Problems when submitting via FTP" << std::endl;
       return -1;
       }
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Using HTTP trigger method"
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Using HTTP trigger method"
       << std::endl
-      << "   Trigger site: " << m_CTest->GetCTestConfiguration("TriggerSite")
+      << "   Trigger site: "
+      << this->CTest->GetCTestConfiguration("TriggerSite")
       << std::endl);
     if ( !this->TriggerUsingHTTP(files, prefix,
-        m_CTest->GetCTestConfiguration("TriggerSite")) )
+        this->CTest->GetCTestConfiguration("TriggerSite")) )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE,
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
         "   Problems when triggering via HTTP" << std::endl);
       ofs << "   Problems when triggering via HTTP" << std::endl;
       return -1;
       }
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Submission successful"
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Submission successful"
       << std::endl);
     ofs << "   Submission successful" << std::endl;
     return 0;
     }
-  else if ( m_CTest->GetCTestConfiguration("DropMethod") == "http" )
+  else if ( this->CTest->GetCTestConfiguration("DropMethod") == "http" )
     {
     ofs << "Using drop method: HTTP" << std::endl;
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Using HTTP submit method"
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Using HTTP submit method"
       << std::endl
       << "   Drop site: http://");
     std::string url = "http://";
-    if ( m_CTest->GetCTestConfiguration("DropSiteUser").size() > 0 )
+    if ( this->CTest->GetCTestConfiguration("DropSiteUser").size() > 0 )
       {
-      url += m_CTest->GetCTestConfiguration("DropSiteUser");
-      cmCTestLog(m_CTest, HANDLER_OUTPUT,
-        m_CTest->GetCTestConfiguration("DropSiteUser").c_str());
-      if ( m_CTest->GetCTestConfiguration("DropSitePassword").size() > 0 )
+      url += this->CTest->GetCTestConfiguration("DropSiteUser");
+      cmCTestLog(this->CTest, HANDLER_OUTPUT,
+        this->CTest->GetCTestConfiguration("DropSiteUser").c_str());
+      if ( this->CTest->GetCTestConfiguration("DropSitePassword").size() > 0 )
         {
-        url += ":" + m_CTest->GetCTestConfiguration("DropSitePassword");
-        cmCTestLog(m_CTest, HANDLER_OUTPUT, ":******");
+        url += ":" + this->CTest->GetCTestConfiguration("DropSitePassword");
+        cmCTestLog(this->CTest, HANDLER_OUTPUT, ":******");
         }
       url += "@";
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, "@");
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "@");
       }
-    url += m_CTest->GetCTestConfiguration("DropSite") +
-      m_CTest->GetCTestConfiguration("DropLocation");
-    cmCTestLog(m_CTest, HANDLER_OUTPUT,
-      m_CTest->GetCTestConfiguration("DropSite")
-      << m_CTest->GetCTestConfiguration("DropLocation") << std::endl);
+    url += this->CTest->GetCTestConfiguration("DropSite") +
+      this->CTest->GetCTestConfiguration("DropLocation");
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+      this->CTest->GetCTestConfiguration("DropSite")
+      << this->CTest->GetCTestConfiguration("DropLocation") << std::endl);
     if ( !this->SubmitUsingHTTP(buildDirectory + "/Testing/" +
-        m_CTest->GetCurrentTag(), files, prefix, url) )
+        this->CTest->GetCurrentTag(), files, prefix, url) )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE,
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
         "   Problems when submitting via HTTP" << std::endl);
       ofs << "   Problems when submitting via HTTP" << std::endl;
       return -1;
       }
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Using HTTP trigger method"
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Using HTTP trigger method"
       << std::endl
-      << "   Trigger site: " << m_CTest->GetCTestConfiguration("TriggerSite")
+      << "   Trigger site: "
+      << this->CTest->GetCTestConfiguration("TriggerSite")
       << std::endl);
     if ( !this->TriggerUsingHTTP(files, prefix,
-        m_CTest->GetCTestConfiguration("TriggerSite")) )
+        this->CTest->GetCTestConfiguration("TriggerSite")) )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE,
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
         "   Problems when triggering via HTTP" << std::endl);
       ofs << "   Problems when triggering via HTTP" << std::endl;
       return -1;
       }
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Submission successful"
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Submission successful"
       << std::endl);
     ofs << "   Submission successful" << std::endl;
     return 0;
     }
-  else if ( m_CTest->GetCTestConfiguration("DropMethod") == "xmlrpc" )
+  else if ( this->CTest->GetCTestConfiguration("DropMethod") == "xmlrpc" )
     {
     ofs << "Using drop method: XML-RPC" << std::endl;
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Using XML-RPC submit method"
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Using XML-RPC submit method"
       << std::endl);
-    std::string url = m_CTest->GetCTestConfiguration("DropSite");
-    prefix = m_CTest->GetCTestConfiguration("DropLocation");
+    std::string url = this->CTest->GetCTestConfiguration("DropSite");
+    prefix = this->CTest->GetCTestConfiguration("DropLocation");
     if ( !this->SubmitUsingXMLRPC(buildDirectory + "/Testing/" +
-        m_CTest->GetCurrentTag(), files, prefix, url) )
+        this->CTest->GetCurrentTag(), files, prefix, url) )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE,
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
         "   Problems when submitting via XML-RPC" << std::endl);
       ofs << "   Problems when submitting via XML-RPC" << std::endl;
       return -1;
       }
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Submission successful"
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Submission successful"
       << std::endl);
     ofs << "   Submission successful" << std::endl;
     return 0;
     }
-  else if ( m_CTest->GetCTestConfiguration("DropMethod") == "scp" )
+  else if ( this->CTest->GetCTestConfiguration("DropMethod") == "scp" )
     {
     std::string url;
     std::string oldWorkingDirectory;
-    if ( m_CTest->GetCTestConfiguration("DropSiteUser").size() > 0 )
+    if ( this->CTest->GetCTestConfiguration("DropSiteUser").size() > 0 )
       {
-      url += m_CTest->GetCTestConfiguration("DropSiteUser") + "@";
+      url += this->CTest->GetCTestConfiguration("DropSiteUser") + "@";
       }
-    url += m_CTest->GetCTestConfiguration("DropSite") + ":" +
-      m_CTest->GetCTestConfiguration("DropLocation");
+    url += this->CTest->GetCTestConfiguration("DropSite") + ":" +
+      this->CTest->GetCTestConfiguration("DropLocation");
 
     // change to the build directory so that we can uses a relative path
     // on windows since scp dosn't support "c:" a drive in the path
     oldWorkingDirectory = cmSystemTools::GetCurrentWorkingDirectory();
     cmSystemTools::ChangeDirectory(buildDirectory.c_str());
 
-    if ( !this->SubmitUsingSCP(m_CTest->GetCTestConfiguration("ScpCommand"),
-        "Testing/"+m_CTest->GetCurrentTag(), files, prefix, url) )
+    if ( !this->SubmitUsingSCP(
+        this->CTest->GetCTestConfiguration("ScpCommand"),
+        "Testing/"+this->CTest->GetCurrentTag(), files, prefix, url) )
       {
       cmSystemTools::ChangeDirectory(oldWorkingDirectory.c_str());
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "   Problems when submitting via SCP"
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+        "   Problems when submitting via SCP"
         << std::endl);
       ofs << "   Problems when submitting via SCP" << std::endl;
       return -1;
       }
     cmSystemTools::ChangeDirectory(oldWorkingDirectory.c_str());
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Submission successful"
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Submission successful"
       << std::endl);
     ofs << "   Submission successful" << std::endl;
     return 0;
     }
 
-  cmCTestLog(m_CTest, ERROR_MESSAGE, "   Unknown submission method: \""
-    << m_CTest->GetCTestConfiguration("DropMethod") << "\"" << std::endl);
+  cmCTestLog(this->CTest, ERROR_MESSAGE, "   Unknown submission method: \""
+    << this->CTest->GetCTestConfiguration("DropMethod") << "\"" << std::endl);
   return -1;
 }
 
 //----------------------------------------------------------------------------
 std::string cmCTestSubmitHandler::GetSubmitResultsPrefix()
 {
-  std::string name = m_CTest->GetCTestConfiguration("Site") +
-    "___" + m_CTest->GetCTestConfiguration("BuildName") +
-    "___" + m_CTest->GetCurrentTag() + "-" +
-    m_CTest->GetTestModelString() + "___XML___";
+  std::string name = this->CTest->GetCTestConfiguration("Site") +
+    "___" + this->CTest->GetCTestConfiguration("BuildName") +
+    "___" + this->CTest->GetCurrentTag() + "-" +
+    this->CTest->GetTestModelString() + "___XML___";
   return name;
 }
 
diff --git a/Source/CTest/cmCTestSubmitHandler.h b/Source/CTest/cmCTestSubmitHandler.h
index 0450de8..7c802c5 100644
--- a/Source/CTest/cmCTestSubmitHandler.h
+++ b/Source/CTest/cmCTestSubmitHandler.h
@@ -31,7 +31,7 @@ public:
   cmTypeMacro(cmCTestSubmitHandler, cmCTestGenericHandler);
 
   cmCTestSubmitHandler();
-  ~cmCTestSubmitHandler() { m_LogFile = 0; }
+  ~cmCTestSubmitHandler() { this->LogFile = 0; }
 
   /*
    * The main entry point for this class
@@ -41,7 +41,7 @@ public:
   void Initialize();
   
 private:
-  void SetLogFile(std::ostream* ost) { m_LogFile = ost; }
+  void SetLogFile(std::ostream* ost) { this->LogFile = ost; }
 
   /**
    * Submit file using various ways
@@ -71,12 +71,12 @@ private:
 
   std::string GetSubmitResultsPrefix();
 
-  cmStdString   m_HTTPProxy;
-  int           m_HTTPProxyType;
-  cmStdString   m_HTTPProxyAuth;
-  cmStdString   m_FTPProxy;
-  int           m_FTPProxyType;
-  std::ostream* m_LogFile;
+  cmStdString   HTTPProxy;
+  int           HTTPProxyType;
+  cmStdString   HTTPProxyAuth;
+  cmStdString   FTPProxy;
+  int           FTPProxyType;
+  std::ostream* LogFile;
 };
 
 #endif
diff --git a/Source/CTest/cmCTestTestCommand.cxx b/Source/CTest/cmCTestTestCommand.cxx
index 746f020..f839b69 100644
--- a/Source/CTest/cmCTestTestCommand.cxx
+++ b/Source/CTest/cmCTestTestCommand.cxx
@@ -21,17 +21,17 @@
 
 cmCTestTestCommand::cmCTestTestCommand()
 {
-  m_Arguments[ctt_START] = "START";
-  m_Arguments[ctt_END] = "END";
-  m_Arguments[ctt_STRIDE] = "STRIDE";
-  m_Arguments[ctt_LAST] = 0;
-  m_Last = ctt_LAST;
+  this->Arguments[ctt_START] = "START";
+  this->Arguments[ctt_END] = "END";
+  this->Arguments[ctt_STRIDE] = "STRIDE";
+  this->Arguments[ctt_LAST] = 0;
+  this->Last = ctt_LAST;
 }
 
 cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
 {
   const char* ctestTimeout = m_Makefile->GetDefinition("CTEST_TEST_TIMEOUT");
-  double timeout = m_CTest->GetTimeOut();
+  double timeout = this->CTest->GetTimeOut();
   if ( ctestTimeout )
     {
     timeout = atof(ctestTimeout);
@@ -44,24 +44,25 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
       timeout = 600;
       }
     }
-  m_CTest->SetTimeOut(timeout);
+  this->CTest->SetTimeOut(timeout);
   cmCTestGenericHandler* handler = this->InitializeActualHandler();
-  if ( m_Values[ctt_START] || m_Values[ctt_END] || m_Values[ctt_STRIDE] )
+  if ( this->Values[ctt_START] || this->Values[ctt_END] ||
+    this->Values[ctt_STRIDE] )
     {
     cmOStringStream testsToRunString;
-    if ( m_Values[ctt_START] )
+    if ( this->Values[ctt_START] )
       {
-      testsToRunString << m_Values[ctt_START];
+      testsToRunString << this->Values[ctt_START];
       }
     testsToRunString << ",";
-    if ( m_Values[ctt_END] )
+    if ( this->Values[ctt_END] )
       {
-      testsToRunString << m_Values[ctt_END];
+      testsToRunString << this->Values[ctt_END];
       }
     testsToRunString << ",";
-    if ( m_Values[ctt_STRIDE] )
+    if ( this->Values[ctt_STRIDE] )
       {
-      testsToRunString << m_Values[ctt_STRIDE];
+      testsToRunString << this->Values[ctt_STRIDE];
       }
     handler->SetOption("TestsToRunInformation",
       testsToRunString.str().c_str());
@@ -71,6 +72,6 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
 
 cmCTestGenericHandler* cmCTestTestCommand::InitializeActualHandler()
 {
-  return m_CTest->GetInitializedHandler("test");
+  return this->CTest->GetInitializedHandler("test");
 }
 
diff --git a/Source/CTest/cmCTestTestCommand.h b/Source/CTest/cmCTestTestCommand.h
index 647896d..8831fc3 100644
--- a/Source/CTest/cmCTestTestCommand.h
+++ b/Source/CTest/cmCTestTestCommand.h
@@ -38,8 +38,8 @@ public:
   virtual cmCommand* Clone() 
     {
     cmCTestTestCommand* ni = new cmCTestTestCommand;
-    ni->m_CTest = this->m_CTest;
-    ni->m_CTestScriptHandler = this->m_CTestScriptHandler;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
     }
 
diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx
index 8c9d29c..fe412e2 100644
--- a/Source/CTest/cmCTestTestHandler.cxx
+++ b/Source/CTest/cmCTestTestHandler.cxx
@@ -45,7 +45,7 @@ public:
   virtual cmCommand* Clone()
     {
     cmCTestSubdirCommand* c = new cmCTestSubdirCommand;
-    c->m_TestHandler = m_TestHandler;
+    c->TestHandler = this->TestHandler;
     return c;
     }
 
@@ -66,7 +66,7 @@ public:
 
   cmTypeMacro(cmCTestSubdirCommand, cmCommand);
 
-  cmCTestTestHandler* m_TestHandler;
+  cmCTestTestHandler* TestHandler;
 };
 
 //----------------------------------------------------------------------
@@ -135,7 +135,7 @@ public:
   virtual cmCommand* Clone()
     {
     cmCTestAddTestCommand* c = new cmCTestAddTestCommand;
-    c->m_TestHandler = m_TestHandler;
+    c->TestHandler = this->TestHandler;
     return c;
     }
 
@@ -156,7 +156,7 @@ public:
 
   cmTypeMacro(cmCTestAddTestCommand, cmCommand);
 
-  cmCTestTestHandler* m_TestHandler;
+  cmCTestTestHandler* TestHandler;
 };
 
 //----------------------------------------------------------------------
@@ -167,7 +167,7 @@ bool cmCTestAddTestCommand::InitialPass(std::vector<std::string> const& args)
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  return m_TestHandler->AddTest(args);
+  return this->TestHandler->AddTest(args);
 }
 
 //----------------------------------------------------------------------
@@ -181,7 +181,7 @@ public:
     {
     cmCTestSetTestsPropertiesCommand* c
       = new cmCTestSetTestsPropertiesCommand;
-    c->m_TestHandler = m_TestHandler;
+    c->TestHandler = this->TestHandler;
     return c;
     }
 
@@ -202,14 +202,14 @@ public:
 
   cmTypeMacro(cmCTestSetTestsPropertiesCommand, cmCommand);
 
-  cmCTestTestHandler* m_TestHandler;
+  cmCTestTestHandler* TestHandler;
 };
 
 //----------------------------------------------------------------------
 bool cmCTestSetTestsPropertiesCommand::InitialPass(
   std::vector<std::string> const& args)
 {
-  return m_TestHandler->SetTestsProperties(args);
+  return this->TestHandler->SetTestsProperties(args);
 }
 
 //----------------------------------------------------------------------
@@ -335,20 +335,20 @@ inline int GetNextRealNumber(std::string const& in,
 //----------------------------------------------------------------------
 cmCTestTestHandler::cmCTestTestHandler()
 {
-  m_UseUnion = false;
+  this->UseUnion = false;
 
-  m_UseIncludeRegExp       = false;
-  m_UseExcludeRegExp       = false;
-  m_UseExcludeRegExpFirst  = false;
+  this->UseIncludeRegExpFlag   = false;
+  this->UseExcludeRegExpFlag   = false;
+  this->UseExcludeRegExpFirst  = false;
 
-  m_CustomMaximumPassedTestOutputSize = 1 * 1024;
-  m_CustomMaximumFailedTestOutputSize = 300 * 1024;
+  this->CustomMaximumPassedTestOutputSize = 1 * 1024;
+  this->CustomMaximumFailedTestOutputSize = 300 * 1024;
 
-  m_MemCheck = false;
+  this->MemCheck = false;
 
-  m_LogFile = 0;
+  this->LogFile = 0;
 
-  m_DartStuff.compile("(<DartMeasurement.*/DartMeasurement[a-zA-Z]*>)");
+  this->DartStuff.compile("(<DartMeasurement.*/DartMeasurement[a-zA-Z]*>)");
 }
 
 //----------------------------------------------------------------------
@@ -356,56 +356,56 @@ void cmCTestTestHandler::Initialize()
 {
   this->Superclass::Initialize();
 
-  m_ElapsedTestingTime = -1;
+  this->ElapsedTestingTime = -1;
 
-  m_TestResults.clear();
+  this->TestResults.clear();
 
-  m_CustomTestsIgnore.clear();
-  m_StartTest = "";
-  m_EndTest = "";
+  this->CustomTestsIgnore.clear();
+  this->StartTest = "";
+  this->EndTest = "";
 
-  m_CustomPreTest.clear();
-  m_CustomPostTest.clear();
-  m_CustomMaximumPassedTestOutputSize = 1 * 1024;
-  m_CustomMaximumFailedTestOutputSize = 300 * 1024;
+  this->CustomPreTest.clear();
+  this->CustomPostTest.clear();
+  this->CustomMaximumPassedTestOutputSize = 1 * 1024;
+  this->CustomMaximumFailedTestOutputSize = 300 * 1024;
 
-  m_TestsToRun.clear();
+  this->TestsToRun.clear();
 
-  m_UseIncludeRegExp = false;
-  m_UseExcludeRegExp = false;
-  m_UseExcludeRegExpFirst = false;
-  m_IncludeRegExp = "";
-  m_ExcludeRegExp = "";
+  this->UseIncludeRegExpFlag = false;
+  this->UseExcludeRegExpFlag = false;
+  this->UseExcludeRegExpFirst = false;
+  this->IncludeRegExp = "";
+  this->ExcludeRegExp = "";
 
   TestsToRunString = "";
-  m_UseUnion = false;
-  m_TestList.clear();
+  this->UseUnion = false;
+  this->TestList.clear();
 }
 
 //----------------------------------------------------------------------
 void cmCTestTestHandler::PopulateCustomVectors(cmMakefile *mf)
 {
   cmCTest::PopulateCustomVector(mf, "CTEST_CUSTOM_PRE_TEST",
-                                m_CustomPreTest);
+                                this->CustomPreTest);
   cmCTest::PopulateCustomVector(mf, "CTEST_CUSTOM_POST_TEST",
-                                m_CustomPostTest);
+                                this->CustomPostTest);
   cmCTest::PopulateCustomVector(mf,
                              "CTEST_CUSTOM_TESTS_IGNORE",
-                             m_CustomTestsIgnore);
+                             this->CustomTestsIgnore);
   cmCTest::PopulateCustomInteger(mf,
                              "CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE",
-                             m_CustomMaximumPassedTestOutputSize);
+                             this->CustomMaximumPassedTestOutputSize);
   cmCTest::PopulateCustomInteger(mf,
                              "CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE",
-                             m_CustomMaximumFailedTestOutputSize);
+                             this->CustomMaximumFailedTestOutputSize);
 }
 
 //----------------------------------------------------------------------
 int cmCTestTestHandler::PreProcessHandler()
 {
-  if ( !this->ExecuteCommands(m_CustomPreTest) )
+  if ( !this->ExecuteCommands(this->CustomPreTest) )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE,
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
       "Problem executing pre-test command(s)." << std::endl);
     return 0;
     }
@@ -415,9 +415,9 @@ int cmCTestTestHandler::PreProcessHandler()
 //----------------------------------------------------------------------
 int cmCTestTestHandler::PostProcessHandler()
 {
-  if ( !this->ExecuteCommands(m_CustomPostTest) )
+  if ( !this->ExecuteCommands(this->CustomPostTest) )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE,
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
       "Problem executing post-test command(s)." << std::endl);
     return 0;
     }
@@ -446,9 +446,10 @@ int cmCTestTestHandler::ProcessHandler()
     this->SetExcludeRegExp(val);
     }
 
-  m_TestResults.clear();
+  this->TestResults.clear();
 
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, (m_MemCheck ? "Memory check" : "Test")
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+    (this->MemCheck ? "Memory check" : "Test")
     << " project" << std::endl);
   if ( ! this->PreProcessHandler() )
     {
@@ -457,7 +458,7 @@ int cmCTestTestHandler::ProcessHandler()
 
   cmGeneratedFileStream mLogFile;
   this->StartLogFile("Tests", mLogFile);
-  m_LogFile = &mLogFile;
+  this->LogFile = &mLogFile;
 
   std::vector<cmStdString> passed;
   std::vector<cmStdString> failed;
@@ -469,23 +470,24 @@ int cmCTestTestHandler::ProcessHandler()
 
   if (total == 0)
     {
-    if ( !m_CTest->GetShowOnly() )
+    if ( !this->CTest->GetShowOnly() )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "No tests were found!!!"
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "No tests were found!!!"
         << std::endl);
       }
     }
   else
     {
-    if (m_HandlerVerbose && passed.size() &&
-      (m_UseIncludeRegExp || m_UseExcludeRegExp))
+    if (this->HandlerVerbose && passed.size() &&
+      (this->UseIncludeRegExpFlag || this->UseExcludeRegExpFlag))
       {
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, std::endl
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
         << "The following tests passed:" << std::endl);
       for(std::vector<cmStdString>::iterator j = passed.begin();
           j != passed.end(); ++j)
         {
-        cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "\t" << *j << std::endl);
+        cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "\t" << *j
+          << std::endl);
         }
       }
 
@@ -494,7 +496,7 @@ int cmCTestTestHandler::ProcessHandler()
       {
       percent = 99;
       }
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, std::endl
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl
       << static_cast<int>(percent + .5) << "% tests passed, "
       << failed.size() << " tests failed out of " << total << std::endl);
     //fprintf(stderr,"\n%.0f%% tests passed, %i tests failed out of %i\n",
@@ -504,36 +506,36 @@ int cmCTestTestHandler::ProcessHandler()
       {
       cmGeneratedFileStream ofs;
 
-      cmCTestLog(m_CTest, ERROR_MESSAGE, std::endl
+      cmCTestLog(this->CTest, ERROR_MESSAGE, std::endl
         << "The following tests FAILED:" << std::endl);
       this->StartLogFile("TestsFailed", ofs);
 
       std::vector<cmCTestTestHandler::cmCTestTestResult>::iterator ftit;
-      for(ftit = m_TestResults.begin();
-        ftit != m_TestResults.end(); ++ftit)
+      for(ftit = this->TestResults.begin();
+        ftit != this->TestResults.end(); ++ftit)
         {
-        if ( ftit->m_Status != cmCTestTestHandler::COMPLETED )
+        if ( ftit->Status != cmCTestTestHandler::COMPLETED )
           {
-          ofs << ftit->m_TestCount << ":" << ftit->m_Name << std::endl;
-          cmCTestLog(m_CTest, HANDLER_OUTPUT, "\t" << std::setw(3)
-            << ftit->m_TestCount << " - " << ftit->m_Name.c_str() << " ("
-            << this->GetTestStatus(ftit->m_Status) << ")" << std::endl);
+          ofs << ftit->TestCount << ":" << ftit->Name << std::endl;
+          cmCTestLog(this->CTest, HANDLER_OUTPUT, "\t" << std::setw(3)
+            << ftit->TestCount << " - " << ftit->Name.c_str() << " ("
+            << this->GetTestStatus(ftit->Status) << ")" << std::endl);
           }
         }
 
       }
     }
 
-  if ( m_CTest->GetProduceXML() )
+  if ( this->CTest->GetProduceXML() )
     {
     cmGeneratedFileStream xmlfile;
-    if( !this->StartResultingXML((m_MemCheck ? "DynamicAnalysis" : "Test"),
-        xmlfile) )
+    if( !this->StartResultingXML(
+        (this->MemCheck ? "DynamicAnalysis" : "Test"), xmlfile) )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create "
-        << (m_MemCheck ? "memory check" : "testing")
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create "
+        << (this->MemCheck ? "memory check" : "testing")
         << " XML file" << std::endl);
-      m_LogFile = 0;
+      this->LogFile = 0;
       return 1;
       }
     this->GenerateDartOutput(xmlfile);
@@ -541,16 +543,16 @@ int cmCTestTestHandler::ProcessHandler()
 
   if ( ! this->PostProcessHandler() )
     {
-    m_LogFile = 0;
+    this->LogFile = 0;
     return -1;
     }
 
   if ( !failed.empty() )
     {
-    m_LogFile = 0;
+    this->LogFile = 0;
     return -1;
     }
-  m_LogFile = 0;
+  this->LogFile = 0;
   return 0;
 }
 
@@ -559,30 +561,30 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
                                           std::vector<cmStdString> &failed)
 {
   std::string current_dir = cmSystemTools::GetCurrentWorkingDirectory();
-  m_TestList.clear();
+  this->TestList.clear();
 
   this->GetListOfTests();
-  tm_ListOfTests::size_type tmsize = m_TestList.size();
+  cmCTestTestHandler::ListOfTests::size_type tmsize = this->TestList.size();
 
-  m_StartTest = m_CTest->CurrentTime();
+  this->StartTest = this->CTest->CurrentTime();
   double elapsed_time_start = cmSystemTools::GetTime();
 
-  *m_LogFile << "Start testing: " << m_StartTest << std::endl
+  *this->LogFile << "Start testing: " << this->StartTest << std::endl
     << "----------------------------------------------------------"
     << std::endl;
 
   // how many tests are in based on RegExp?
   int inREcnt = 0;
-  tm_ListOfTests::iterator it;
-  for ( it = m_TestList.begin(); it != m_TestList.end(); it ++ )
+  cmCTestTestHandler::ListOfTests::iterator it;
+  for ( it = this->TestList.begin(); it != this->TestList.end(); it ++ )
     {
-    if (it->m_IsInBasedOnREOptions)
+    if (it->IsInBasedOnREOptions)
       {
       inREcnt ++;
       }
     }
   // expand the test list based on the union flag
-  if (m_UseUnion)
+  if (this->UseUnion)
     {
     this->ExpandTestsToRunInformation((int)tmsize);
     }
@@ -594,39 +596,39 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
   int cnt = 0;
   inREcnt = 0;
   std::string last_directory = "";
-  for ( it = m_TestList.begin(); it != m_TestList.end(); it ++ )
+  for ( it = this->TestList.begin(); it != this->TestList.end(); it ++ )
     {
     cnt ++;
-    if (it->m_IsInBasedOnREOptions)
+    if (it->IsInBasedOnREOptions)
       {
       inREcnt++;
       }
-    const std::string& testname = it->m_Name;
-    std::vector<std::string>& args = it->m_Args;
+    const std::string& testname = it->Name;
+    std::vector<std::string>& args = it->Args;
     cmCTestTestResult cres;
-    cres.m_ExecutionTime = 0;
-    cres.m_ReturnValue = -1;
-    cres.m_Status = cmCTestTestHandler::NOT_RUN;
-    cres.m_TestCount = cnt;
+    cres.ExecutionTime = 0;
+    cres.ReturnValue = -1;
+    cres.Status = cmCTestTestHandler::NOT_RUN;
+    cres.TestCount = cnt;
 
-    if (!(last_directory == it->m_Directory))
+    if (!(last_directory == it->Directory))
       {
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Changing directory into "
-        << it->m_Directory.c_str() << "\n");
-      *m_LogFile << "Changing directory into: " << it->m_Directory.c_str()
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+        "Changing directory into " << it->Directory.c_str() << "\n");
+      *this->LogFile << "Changing directory into: " << it->Directory.c_str()
         << std::endl;
-      last_directory = it->m_Directory;
-      cmSystemTools::ChangeDirectory(it->m_Directory.c_str());
+      last_directory = it->Directory;
+      cmSystemTools::ChangeDirectory(it->Directory.c_str());
       }
-    cres.m_Name = testname;
-    cres.m_Path = it->m_Directory.c_str();
+    cres.Name = testname;
+    cres.Path = it->Directory.c_str();
 
-    if (m_UseUnion)
+    if (this->UseUnion)
       {
       // if it is not in the list and not in the regexp then skip
-      if ((m_TestsToRun.size() &&
-           std::find(m_TestsToRun.begin(), m_TestsToRun.end(), cnt)
-           == m_TestsToRun.end()) && !it->m_IsInBasedOnREOptions)
+      if ((this->TestsToRun.size() &&
+           std::find(this->TestsToRun.begin(), this->TestsToRun.end(), cnt)
+           == this->TestsToRun.end()) && !it->IsInBasedOnREOptions)
         {
         continue;
         }
@@ -634,40 +636,41 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
     else
       {
       // is this test in the list of tests to run? If not then skip it
-      if ((m_TestsToRun.size() &&
-           std::find(m_TestsToRun.begin(), m_TestsToRun.end(), inREcnt)
-           == m_TestsToRun.end()) || !it->m_IsInBasedOnREOptions)
+      if ((this->TestsToRun.size() &&
+           std::find(this->TestsToRun.begin(),
+             this->TestsToRun.end(), inREcnt)
+           == this->TestsToRun.end()) || !it->IsInBasedOnREOptions)
         {
         continue;
         }
       }
 
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, std::setw(3) << cnt << "/");
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, std::setw(3) << tmsize << " ");
-    if ( m_MemCheck )
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(3) << cnt << "/");
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(3) << tmsize << " ");
+    if ( this->MemCheck )
       {
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, "Memory Check");
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "Memory Check");
       }
     else
       {
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, "Testing");
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "Testing");
       }
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, " ");
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, " ");
     std::string outname = testname;
     outname.resize(30, ' ');
-    *m_LogFile << cnt << "/" << tmsize << " Testing: " << testname
+    *this->LogFile << cnt << "/" << tmsize << " Testing: " << testname
       << std::endl;
 
-    if ( m_CTest->GetShowOnly() )
+    if ( this->CTest->GetShowOnly() )
       {
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, outname.c_str() << std::endl);
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, outname.c_str() << std::endl);
       }
     else
       {
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, outname.c_str());
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, outname.c_str());
       }
 
-    cmCTestLog(m_CTest, DEBUG, "Testing " << args[0].c_str() << " ... ");
+    cmCTestLog(this->CTest, DEBUG, "Testing " << args[0].c_str() << " ... ");
     // find the test executable
     std::string actualCommand = this->FindTheExecutable(args[1].c_str());
     std::string testCommand
@@ -676,14 +679,14 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
     // continue if we did not find the executable
     if (testCommand == "")
       {
-      *m_LogFile << "Unable to find executable: " << args[1].c_str()
+      *this->LogFile << "Unable to find executable: " << args[1].c_str()
         << std::endl;
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "Unable to find executable: "
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Unable to find executable: "
         << args[1].c_str() << std::endl);
-      if ( !m_CTest->GetShowOnly() )
+      if ( !this->CTest->GetShowOnly() )
         {
-        cres.m_FullCommandLine = actualCommand;
-        m_TestResults.push_back( cres );
+        cres.FullCommandLine = actualCommand;
+        this->TestResults.push_back( cres );
         failed.push_back(testname);
         continue;
         }
@@ -711,22 +714,22 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
     int retVal = 0;
 
 
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, std::endl
-      << (m_MemCheck?"MemCheck":"Test") << " command: " << testCommand
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
+      << (this->MemCheck?"MemCheck":"Test") << " command: " << testCommand
       << std::endl);
-    *m_LogFile << cnt << "/" << tmsize
+    *this->LogFile << cnt << "/" << tmsize
       << " Test: " << testname.c_str() << std::endl;
-    *m_LogFile << "Command: ";
+    *this->LogFile << "Command: ";
     std::vector<cmStdString>::size_type ll;
     for ( ll = 0; ll < arguments.size()-1; ll ++ )
       {
-      *m_LogFile << "\"" << arguments[ll] << "\" ";
+      *this->LogFile << "\"" << arguments[ll] << "\" ";
       }
-    *m_LogFile
+    *this->LogFile
       << std::endl
-      << "Directory: " << it->m_Directory << std::endl
+      << "Directory: " << it->Directory << std::endl
       << "\"" << testname.c_str() << "\" start time: "
-      << m_CTest->CurrentTime() << std::endl
+      << this->CTest->CurrentTime() << std::endl
       << "Output:" << std::endl
       << "----------------------------------------------------------"
       << std::endl;
@@ -734,14 +737,14 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
     double clock_start, clock_finish;
     clock_start = cmSystemTools::GetTime();
 
-    if ( !m_CTest->GetShowOnly() )
+    if ( !this->CTest->GetShowOnly() )
       {
-      res = m_CTest->RunTest(arguments, &output, &retVal, m_LogFile);
+      res = this->CTest->RunTest(arguments, &output, &retVal, this->LogFile);
       }
 
     clock_finish = cmSystemTools::GetTime();
 
-    if ( m_LogFile )
+    if ( this->LogFile )
       {
       double ttime = clock_finish - clock_start;
       int hours = static_cast<int>(ttime / (60 * 60));
@@ -749,30 +752,30 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
       int seconds = static_cast<int>(ttime) % 60;
       char buffer[100];
       sprintf(buffer, "%02d:%02d:%02d", hours, minutes, seconds);
-      *m_LogFile
+      *this->LogFile
         << "----------------------------------------------------------"
         << std::endl
         << "\"" << testname.c_str() << "\" end time: "
-        << m_CTest->CurrentTime() << std::endl
+        << this->CTest->CurrentTime() << std::endl
         << "\"" << testname.c_str() << "\" time elapsed: "
         << buffer << std::endl
         << "----------------------------------------------------------"
         << std::endl << std::endl;
       }
 
-    cres.m_ExecutionTime = (double)(clock_finish - clock_start);
-    cres.m_FullCommandLine = testCommand;
+    cres.ExecutionTime = (double)(clock_finish - clock_start);
+    cres.FullCommandLine = testCommand;
 
-    if ( !m_CTest->GetShowOnly() )
+    if ( !this->CTest->GetShowOnly() )
       {
       bool testFailed = false;
       std::vector<cmsys::RegularExpression>::iterator passIt;
       bool forceFail = false;
-      if ( it->m_RequiredRegularExpressions.size() > 0 )
+      if ( it->RequiredRegularExpressions.size() > 0 )
         {
         bool found = false;
-        for ( passIt = it->m_RequiredRegularExpressions.begin();
-          passIt != it->m_RequiredRegularExpressions.end();
+        for ( passIt = it->RequiredRegularExpressions.begin();
+          passIt != it->RequiredRegularExpressions.end();
           ++ passIt )
           {
           if ( passIt->find(output.c_str()) )
@@ -785,10 +788,10 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
           forceFail = true;
           }
         }
-      if ( it->m_ErrorRegularExpressions.size() > 0 )
+      if ( it->ErrorRegularExpressions.size() > 0 )
         {
-        for ( passIt = it->m_ErrorRegularExpressions.begin();
-          passIt != it->m_ErrorRegularExpressions.end();
+        for ( passIt = it->ErrorRegularExpressions.begin();
+          passIt != it->ErrorRegularExpressions.end();
           ++ passIt )
           {
           if ( passIt->find(output.c_str()) )
@@ -799,76 +802,76 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
         }
 
       if (res == cmsysProcess_State_Exited &&
-          (retVal == 0 || it->m_RequiredRegularExpressions.size()) &&
+          (retVal == 0 || it->RequiredRegularExpressions.size()) &&
           !forceFail)
         {
-        cmCTestLog(m_CTest, HANDLER_OUTPUT,   "   Passed");
-        if ( it->m_WillFail )
+        cmCTestLog(this->CTest, HANDLER_OUTPUT,   "   Passed");
+        if ( it->WillFail )
           {
-          cmCTestLog(m_CTest, HANDLER_OUTPUT,   " - But it should fail!");
-          cres.m_Status = cmCTestTestHandler::FAILED;
+          cmCTestLog(this->CTest, HANDLER_OUTPUT,   " - But it should fail!");
+          cres.Status = cmCTestTestHandler::FAILED;
           testFailed = true;
           }
         else
           {
-          cres.m_Status = cmCTestTestHandler::COMPLETED;
+          cres.Status = cmCTestTestHandler::COMPLETED;
           }
-        cmCTestLog(m_CTest, HANDLER_OUTPUT, std::endl);
+        cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
         }
       else
         {
         testFailed = true;
 
-        cres.m_Status = cmCTestTestHandler::FAILED;
+        cres.Status = cmCTestTestHandler::FAILED;
         if ( res == cmsysProcess_State_Expired )
           {
-          cmCTestLog(m_CTest, HANDLER_OUTPUT, "***Timeout" << std::endl);
-          cres.m_Status = cmCTestTestHandler::TIMEOUT;
+          cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Timeout" << std::endl);
+          cres.Status = cmCTestTestHandler::TIMEOUT;
           }
         else if ( res == cmsysProcess_State_Exception )
           {
-          cmCTestLog(m_CTest, HANDLER_OUTPUT, "***Exception: ");
+          cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Exception: ");
           switch ( retVal )
             {
           case cmsysProcess_Exception_Fault:
-            cmCTestLog(m_CTest, HANDLER_OUTPUT, "SegFault");
-            cres.m_Status = cmCTestTestHandler::SEGFAULT;
+            cmCTestLog(this->CTest, HANDLER_OUTPUT, "SegFault");
+            cres.Status = cmCTestTestHandler::SEGFAULT;
             break;
           case cmsysProcess_Exception_Illegal:
-            cmCTestLog(m_CTest, HANDLER_OUTPUT, "Illegal");
-            cres.m_Status = cmCTestTestHandler::ILLEGAL;
+            cmCTestLog(this->CTest, HANDLER_OUTPUT, "Illegal");
+            cres.Status = cmCTestTestHandler::ILLEGAL;
             break;
           case cmsysProcess_Exception_Interrupt:
-            cmCTestLog(m_CTest, HANDLER_OUTPUT, "Interrupt");
-            cres.m_Status = cmCTestTestHandler::INTERRUPT;
+            cmCTestLog(this->CTest, HANDLER_OUTPUT, "Interrupt");
+            cres.Status = cmCTestTestHandler::INTERRUPT;
             break;
           case cmsysProcess_Exception_Numerical:
-            cmCTestLog(m_CTest, HANDLER_OUTPUT, "Numerical");
-            cres.m_Status = cmCTestTestHandler::NUMERICAL;
+            cmCTestLog(this->CTest, HANDLER_OUTPUT, "Numerical");
+            cres.Status = cmCTestTestHandler::NUMERICAL;
             break;
           default:
-            cmCTestLog(m_CTest, HANDLER_OUTPUT, "Other");
-            cres.m_Status = cmCTestTestHandler::OTHER_FAULT;
+            cmCTestLog(this->CTest, HANDLER_OUTPUT, "Other");
+            cres.Status = cmCTestTestHandler::OTHER_FAULT;
             }
-           cmCTestLog(m_CTest, HANDLER_OUTPUT, std::endl);
+           cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
           }
         else if ( res == cmsysProcess_State_Error )
           {
-          cmCTestLog(m_CTest, HANDLER_OUTPUT, "***Bad command " << res
+          cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Bad command " << res
             << std::endl);
-          cres.m_Status = cmCTestTestHandler::BAD_COMMAND;
+          cres.Status = cmCTestTestHandler::BAD_COMMAND;
           }
         else
           {
           // Force fail will also be here?
-          cmCTestLog(m_CTest, HANDLER_OUTPUT, "***Failed");
-          if ( it->m_WillFail )
+          cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Failed");
+          if ( it->WillFail )
             {
-            cres.m_Status = cmCTestTestHandler::COMPLETED;
-            cmCTestLog(m_CTest, HANDLER_OUTPUT, " - supposed to fail");
+            cres.Status = cmCTestTestHandler::COMPLETED;
+            cmCTestLog(this->CTest, HANDLER_OUTPUT, " - supposed to fail");
             testFailed = false;
             }
-          cmCTestLog(m_CTest, HANDLER_OUTPUT, std::endl);
+          cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
           }
         }
       if ( testFailed )
@@ -881,38 +884,38 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
         }
       if (!output.empty() && output.find("<DartMeasurement") != output.npos)
         {
-        if (m_DartStuff.find(output.c_str()))
+        if (this->DartStuff.find(output.c_str()))
           {
-          std::string dartString = m_DartStuff.match(1);
+          std::string dartString = this->DartStuff.match(1);
           cmSystemTools::ReplaceString(output, dartString.c_str(),"");
-          cres.m_RegressionImages
+          cres.RegressionImages
             = this->GenerateRegressionImages(dartString);
           }
         }
       }
 
-    if ( cres.m_Status == cmCTestTestHandler::COMPLETED )
+    if ( cres.Status == cmCTestTestHandler::COMPLETED )
       {
       this->CleanTestOutput(output, static_cast<size_t>(
-          m_CustomMaximumPassedTestOutputSize));
+          this->CustomMaximumPassedTestOutputSize));
       }
     else
       {
       this->CleanTestOutput(output, static_cast<size_t>(
-          m_CustomMaximumFailedTestOutputSize));
+          this->CustomMaximumFailedTestOutputSize));
       }
 
-    cres.m_Output = output;
-    cres.m_ReturnValue = retVal;
-    cres.m_CompletionStatus = "Completed";
-    m_TestResults.push_back( cres );
+    cres.Output = output;
+    cres.ReturnValue = retVal;
+    cres.CompletionStatus = "Completed";
+    this->TestResults.push_back( cres );
     }
 
-  m_EndTest = m_CTest->CurrentTime();
-  m_ElapsedTestingTime = cmSystemTools::GetTime() - elapsed_time_start;
-  if ( m_LogFile )
+  this->EndTest = this->CTest->CurrentTime();
+  this->ElapsedTestingTime = cmSystemTools::GetTime() - elapsed_time_start;
+  if ( this->LogFile )
     {
-    *m_LogFile << "End testing: " << m_EndTest << std::endl;
+    *this->LogFile << "End testing: " << this->EndTest << std::endl;
     }
   cmSystemTools::ChangeDirectory(current_dir.c_str());
 }
@@ -925,34 +928,34 @@ void cmCTestTestHandler::GenerateTestCommand(std::vector<const char*>&)
 //----------------------------------------------------------------------
 void cmCTestTestHandler::GenerateDartOutput(std::ostream& os)
 {
-  if ( !m_CTest->GetProduceXML() )
+  if ( !this->CTest->GetProduceXML() )
     {
     return;
     }
 
-  m_CTest->StartXML(os);
+  this->CTest->StartXML(os);
   os << "<Testing>\n"
-    << "\t<StartDateTime>" << m_StartTest << "</StartDateTime>\n"
+    << "\t<StartDateTime>" << this->StartTest << "</StartDateTime>\n"
     << "\t<TestList>\n";
-  tm_TestResultsVector::size_type cc;
-  for ( cc = 0; cc < m_TestResults.size(); cc ++ )
+  cmCTestTestHandler::TestResultsVector::size_type cc;
+  for ( cc = 0; cc < this->TestResults.size(); cc ++ )
     {
-    cmCTestTestResult *result = &m_TestResults[cc];
-    std::string testPath = result->m_Path + "/" + result->m_Name;
+    cmCTestTestResult *result = &this->TestResults[cc];
+    std::string testPath = result->Path + "/" + result->Name;
     os << "\t\t<Test>" << cmCTest::MakeXMLSafe(
-      m_CTest->GetShortPathToFile(testPath.c_str()))
+      this->CTest->GetShortPathToFile(testPath.c_str()))
       << "</Test>" << std::endl;
     }
   os << "\t</TestList>\n";
-  for ( cc = 0; cc < m_TestResults.size(); cc ++ )
+  for ( cc = 0; cc < this->TestResults.size(); cc ++ )
     {
-    cmCTestTestResult *result = &m_TestResults[cc];
+    cmCTestTestResult *result = &this->TestResults[cc];
     os << "\t<Test Status=\"";
-    if ( result->m_Status == cmCTestTestHandler::COMPLETED )
+    if ( result->Status == cmCTestTestHandler::COMPLETED )
       {
       os << "passed";
       }
-    else if ( result->m_Status == cmCTestTestHandler::NOT_RUN )
+    else if ( result->Status == cmCTestTestHandler::NOT_RUN )
       {
       os << "notrun";
       }
@@ -960,44 +963,44 @@ void cmCTestTestHandler::GenerateDartOutput(std::ostream& os)
       {
       os << "failed";
       }
-    std::string testPath = result->m_Path + "/" + result->m_Name;
+    std::string testPath = result->Path + "/" + result->Name;
     os << "\">\n"
-      << "\t\t<Name>" << cmCTest::MakeXMLSafe(result->m_Name) << "</Name>\n"
+      << "\t\t<Name>" << cmCTest::MakeXMLSafe(result->Name) << "</Name>\n"
       << "\t\t<Path>" << cmCTest::MakeXMLSafe(
-        m_CTest->GetShortPathToFile(result->m_Path.c_str())) << "</Path>\n"
+        this->CTest->GetShortPathToFile(result->Path.c_str())) << "</Path>\n"
       << "\t\t<FullName>" << cmCTest::MakeXMLSafe(
-        m_CTest->GetShortPathToFile(testPath.c_str())) << "</FullName>\n"
+        this->CTest->GetShortPathToFile(testPath.c_str())) << "</FullName>\n"
       << "\t\t<FullCommandLine>"
-      << cmCTest::MakeXMLSafe(result->m_FullCommandLine)
+      << cmCTest::MakeXMLSafe(result->FullCommandLine)
       << "</FullCommandLine>\n"
       << "\t\t<Results>" << std::endl;
-    if ( result->m_Status != cmCTestTestHandler::NOT_RUN )
+    if ( result->Status != cmCTestTestHandler::NOT_RUN )
       {
-      if ( result->m_Status != cmCTestTestHandler::COMPLETED ||
-        result->m_ReturnValue )
+      if ( result->Status != cmCTestTestHandler::COMPLETED ||
+        result->ReturnValue )
         {
         os << "\t\t\t<NamedMeasurement type=\"text/string\" "
           "name=\"Exit Code\"><Value>"
-          << this->GetTestStatus(result->m_Status) << "</Value>"
+          << this->GetTestStatus(result->Status) << "</Value>"
           "</NamedMeasurement>\n"
           << "\t\t\t<NamedMeasurement type=\"text/string\" "
           "name=\"Exit Value\"><Value>"
-          << result->m_ReturnValue << "</Value></NamedMeasurement>"
+          << result->ReturnValue << "</Value></NamedMeasurement>"
           << std::endl;
         }
-      os << result->m_RegressionImages;
+      os << result->RegressionImages;
       os << "\t\t\t<NamedMeasurement type=\"numeric/double\" "
         << "name=\"Execution Time\"><Value>"
-        << result->m_ExecutionTime << "</Value></NamedMeasurement>\n";
+        << result->ExecutionTime << "</Value></NamedMeasurement>\n";
       os
         << "\t\t\t<NamedMeasurement type=\"text/string\" "
         << "name=\"Completion Status\"><Value>"
-        << result->m_CompletionStatus << "</Value></NamedMeasurement>\n";
+        << result->CompletionStatus << "</Value></NamedMeasurement>\n";
       }
     os
       << "\t\t\t<Measurement>\n"
       << "\t\t\t\t<Value>";
-    os << cmCTest::MakeXMLSafe(result->m_Output);
+    os << cmCTest::MakeXMLSafe(result->Output);
     os
       << "</Value>\n"
       << "\t\t\t</Measurement>\n"
@@ -1005,12 +1008,12 @@ void cmCTestTestHandler::GenerateDartOutput(std::ostream& os)
       << "\t</Test>" << std::endl;
     }
 
-  os << "\t<EndDateTime>" << m_EndTest << "</EndDateTime>\n"
+  os << "\t<EndDateTime>" << this->EndTest << "</EndDateTime>\n"
      << "<ElapsedMinutes>"
-     << static_cast<int>(m_ElapsedTestingTime/6)/10.0
+     << static_cast<int>(this->ElapsedTestingTime/6)/10.0
      << "</ElapsedMinutes>"
     << "</Testing>" << std::endl;
-  m_CTest->EndXML(os);
+  this->CTest->EndXML(os);
 }
 
 //----------------------------------------------------------------------
@@ -1020,13 +1023,13 @@ int cmCTestTestHandler::ExecuteCommands(std::vector<cmStdString>& vec)
   for ( it = vec.begin(); it != vec.end(); ++it )
     {
     int retVal = 0;
-    cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Run command: " << *it
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command: " << *it
       << std::endl);
     if ( !cmSystemTools::RunSingleCommand(it->c_str(), 0, &retVal, 0, true
-        /*m_Verbose*/) || retVal != 0 )
+        /*this->Verbose*/) || retVal != 0 )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "Problem running command: " << *it
-        << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Problem running command: "
+        << *it << std::endl);
       return 0;
       }
     }
@@ -1045,9 +1048,9 @@ std::string cmCTestTestHandler::FindTheExecutable(const char *exe)
   cmSystemTools::SplitProgramPath(exe, dir, file);
   // first try to find the executable given a config type subdir if there is
   // one
-  if(m_CTest->GetConfigType() != "" &&
+  if(this->CTest->GetConfigType() != "" &&
     ::TryExecutable(dir.c_str(), file.c_str(), &fullPath,
-      m_CTest->GetConfigType().c_str()))
+      this->CTest->GetConfigType().c_str()))
     {
     return fullPath;
     }
@@ -1064,7 +1067,7 @@ std::string cmCTestTestHandler::FindTheExecutable(const char *exe)
     return fullPath;
     }
 
-  if ( m_CTest->GetConfigType() == "" )
+  if ( this->CTest->GetConfigType() == "" )
     {
     // No config type, so try to guess it
     if (::TryExecutable(dir.c_str(),file.c_str(),&fullPath,"Deployment"))
@@ -1109,10 +1112,10 @@ std::string cmCTestTestHandler::FindTheExecutable(const char *exe)
       }
     }
 
-  if ( m_CTest->GetConfigType() != "" )
+  if ( this->CTest->GetConfigType() != "" )
     {
     dir += "/";
-    dir += m_CTest->GetConfigType();
+    dir += this->CTest->GetConfigType();
     dir += "/";
     dir += file;
     cmSystemTools::Error("config type specified on the command line, but "
@@ -1127,16 +1130,16 @@ std::string cmCTestTestHandler::FindTheExecutable(const char *exe)
 //----------------------------------------------------------------------
 void cmCTestTestHandler::GetListOfTests()
 {
-  if ( !m_IncludeRegExp.empty() )
+  if ( !this->IncludeRegExp.empty() )
     {
-    m_IncludeTestsRegularExpression.compile(m_IncludeRegExp.c_str());
+    this->IncludeTestsRegularExpression.compile(this->IncludeRegExp.c_str());
     }
-  if ( !m_ExcludeRegExp.empty() )
+  if ( !this->ExcludeRegExp.empty() )
     {
-    m_ExcludeTestsRegularExpression.compile(m_ExcludeRegExp.c_str());
+    this->ExcludeTestsRegularExpression.compile(this->ExcludeRegExp.c_str());
     }
-  cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Constructing a list of tests"
-    << std::endl);
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+    "Constructing a list of tests" << std::endl);
   cmake cm;
   cmGlobalGenerator gg;
   gg.SetCMakeInstance(&cm);
@@ -1144,22 +1147,22 @@ void cmCTestTestHandler::GetListOfTests()
   lg->SetGlobalGenerator(&gg);
   cmMakefile *mf = lg->GetMakefile();
   mf->AddDefinition("CTEST_CONFIGURATION_TYPE",
-    m_CTest->GetConfigType().c_str());
+    this->CTest->GetConfigType().c_str());
 
   // Add handler for ADD_TEST
   cmCTestAddTestCommand* newCom1 = new cmCTestAddTestCommand;
-  newCom1->m_TestHandler = this;
+  newCom1->TestHandler = this;
   cm.AddCommand(newCom1);
 
   // Add handler for SUBDIR
   cmCTestSubdirCommand* newCom2 = new cmCTestSubdirCommand;
-  newCom2->m_TestHandler = this;
+  newCom2->TestHandler = this;
   cm.AddCommand(newCom2);
 
   // Add handler for SET_SOURCE_FILES_PROPERTIES
   cmCTestSetTestsPropertiesCommand* newCom3
     = new cmCTestSetTestsPropertiesCommand;
-  newCom3->m_TestHandler = this;
+  newCom3->TestHandler = this;
   cm.AddCommand(newCom3);
 
   const char* testFilename;
@@ -1186,21 +1189,21 @@ void cmCTestTestHandler::GetListOfTests()
     {
     return;
     }
-  cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT,
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
     "Done constructing a list of tests" << std::endl);
 }
 
 //----------------------------------------------------------------------
 void cmCTestTestHandler::UseIncludeRegExp()
 {
-  this->m_UseIncludeRegExp = true;
+  this->UseIncludeRegExpFlag = true;
 }
 
 //----------------------------------------------------------------------
 void cmCTestTestHandler::UseExcludeRegExp()
 {
-  this->m_UseExcludeRegExp = true;
-  this->m_UseExcludeRegExpFirst = this->m_UseIncludeRegExp ? false : true;
+  this->UseExcludeRegExpFlag = true;
+  this->UseExcludeRegExpFirst = this->UseIncludeRegExpFlag ? false : true;
 }
 
 //----------------------------------------------------------------------
@@ -1253,9 +1256,9 @@ void cmCTestTestHandler::ExpandTestsToRunInformation(int numTests)
         // now read specific numbers
         while(GetNextNumber(this->TestsToRunString, val, pos, pos2))
           {
-          m_TestsToRun.push_back(val);
+          this->TestsToRun.push_back(val);
           }
-        m_TestsToRun.push_back(val);
+        this->TestsToRun.push_back(val);
         }
       }
     }
@@ -1284,17 +1287,18 @@ void cmCTestTestHandler::ExpandTestsToRunInformation(int numTests)
     int i = 0;
     while (i*stride + start <= end)
       {
-      m_TestsToRun.push_back(static_cast<int>(i*stride+start));
+      this->TestsToRun.push_back(static_cast<int>(i*stride+start));
       ++i;
       }
     }
 
   // sort the array
-  std::sort(m_TestsToRun.begin(), m_TestsToRun.end(), std::less<int>());
+  std::sort(this->TestsToRun.begin(), this->TestsToRun.end(),
+    std::less<int>());
   // remove duplicates
   std::vector<int>::iterator new_end =
-    std::unique(m_TestsToRun.begin(), m_TestsToRun.end());
-  m_TestsToRun.erase(new_end, m_TestsToRun.end());
+    std::unique(this->TestsToRun.begin(), this->TestsToRun.end());
+  this->TestsToRun.erase(new_end, this->TestsToRun.end());
 }
 
 //----------------------------------------------------------------------
@@ -1464,7 +1468,7 @@ std::string cmCTestTestHandler::GenerateRegressionImages(
           << "><Value>File " << filename.c_str()
           << " not found</Value></NamedMeasurement>"
           << std::endl;
-        cmCTestLog(m_CTest, HANDLER_OUTPUT, "File \"" << filename.c_str()
+        cmCTestLog(this->CTest, HANDLER_OUTPUT, "File \"" << filename.c_str()
           << "\" not found." << std::endl);
         }
       cxml.erase(measurementfile.start(),
@@ -1481,13 +1485,13 @@ std::string cmCTestTestHandler::GenerateRegressionImages(
 //----------------------------------------------------------------------
 void cmCTestTestHandler::SetIncludeRegExp(const char *arg)
 {
-  m_IncludeRegExp = arg;
+  this->IncludeRegExp = arg;
 }
 
 //----------------------------------------------------------------------
 void cmCTestTestHandler::SetExcludeRegExp(const char *arg)
 {
-  m_ExcludeRegExp = arg;
+  this->ExcludeRegExp = arg;
 }
 
 //----------------------------------------------------------------------
@@ -1606,14 +1610,16 @@ bool cmCTestTestHandler::SetTestsProperties(
     std::vector<cmStdString>::const_iterator tit;
     for ( tit = tests.begin(); tit != tests.end(); ++ tit )
       {
-      tm_ListOfTests::iterator rtit;
-      for ( rtit = m_TestList.begin(); rtit != m_TestList.end(); ++ rtit )
+      cmCTestTestHandler::ListOfTests::iterator rtit;
+      for ( rtit = this->TestList.begin();
+        rtit != this->TestList.end();
+        ++ rtit )
         {
-        if ( *tit == rtit->m_Name )
+        if ( *tit == rtit->Name )
           {
           if ( key == "WILL_FAIL" )
             {
-            rtit->m_WillFail = cmSystemTools::IsOn(val.c_str());
+            rtit->WillFail = cmSystemTools::IsOn(val.c_str());
             }
           if ( key == "FAIL_REGULAR_EXPRESSION" )
             {
@@ -1622,7 +1628,7 @@ bool cmCTestTestHandler::SetTestsProperties(
             std::vector<std::string>::iterator crit;
             for ( crit = lval.begin(); crit != lval.end(); ++ crit )
               {
-              rtit->m_ErrorRegularExpressions.push_back(
+              rtit->ErrorRegularExpressions.push_back(
                 cmsys::RegularExpression(crit->c_str()));
               }
             }
@@ -1633,7 +1639,7 @@ bool cmCTestTestHandler::SetTestsProperties(
             std::vector<std::string>::iterator crit;
             for ( crit = lval.begin(); crit != lval.end(); ++ crit )
               {
-              rtit->m_RequiredRegularExpressions.push_back(
+              rtit->RequiredRegularExpressions.push_back(
                 cmsys::RegularExpression(crit->c_str()));
               }
             }
@@ -1648,18 +1654,18 @@ bool cmCTestTestHandler::SetTestsProperties(
 bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
 {
   const std::string& testname = args[0];
-  if (this->m_UseExcludeRegExp &&
-    this->m_UseExcludeRegExpFirst &&
-    m_ExcludeTestsRegularExpression.find(testname.c_str()))
+  if (this->UseExcludeRegExpFlag &&
+    this->UseExcludeRegExpFirst &&
+    this->ExcludeTestsRegularExpression.find(testname.c_str()))
     {
     return true;
     }
-  if ( m_MemCheck )
+  if ( this->MemCheck )
     {
     std::vector<cmStdString>::iterator it;
     bool found = false;
-    for ( it = m_CustomTestsIgnore.begin();
-      it != m_CustomTestsIgnore.end(); ++ it )
+    for ( it = this->CustomTestsIgnore.begin();
+      it != this->CustomTestsIgnore.end(); ++ it )
       {
       if ( *it == testname )
         {
@@ -1669,7 +1675,7 @@ bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
       }
     if ( found )
       {
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Ignore memcheck: "
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Ignore memcheck: "
         << *it << std::endl);
       return true;
       }
@@ -1678,8 +1684,8 @@ bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
     {
     std::vector<cmStdString>::iterator it;
     bool found = false;
-    for ( it = m_CustomTestsIgnore.begin();
-      it != m_CustomTestsIgnore.end(); ++ it )
+    for ( it = this->CustomTestsIgnore.begin();
+      it != this->CustomTestsIgnore.end(); ++ it )
       {
       if ( *it == testname )
         {
@@ -1689,30 +1695,30 @@ bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
       }
     if ( found )
       {
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Ignore test: "
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Ignore test: "
         << *it << std::endl);
       return true;
       }
     }
 
   cmCTestTestProperties test;
-  test.m_Name = testname;
-  test.m_Args = args;
-  test.m_Directory = cmSystemTools::GetCurrentWorkingDirectory();
-  test.m_IsInBasedOnREOptions = true;
-  test.m_WillFail = false;
-  if (this->m_UseIncludeRegExp &&
-    !m_IncludeTestsRegularExpression.find(testname.c_str()))
+  test.Name = testname;
+  test.Args = args;
+  test.Directory = cmSystemTools::GetCurrentWorkingDirectory();
+  test.IsInBasedOnREOptions = true;
+  test.WillFail = false;
+  if (this->UseIncludeRegExpFlag &&
+    !this->IncludeTestsRegularExpression.find(testname.c_str()))
     {
-    test.m_IsInBasedOnREOptions = false;
+    test.IsInBasedOnREOptions = false;
     }
-  else if (this->m_UseExcludeRegExp &&
-    !this->m_UseExcludeRegExpFirst &&
-    m_ExcludeTestsRegularExpression.find(testname.c_str()))
+  else if (this->UseExcludeRegExpFlag &&
+    !this->UseExcludeRegExpFirst &&
+    this->ExcludeTestsRegularExpression.find(testname.c_str()))
     {
-    test.m_IsInBasedOnREOptions = false;
+    test.IsInBasedOnREOptions = false;
     }
-  m_TestList.push_back(test);
+  this->TestList.push_back(test);
   return true;
 }
 
diff --git a/Source/CTest/cmCTestTestHandler.h b/Source/CTest/cmCTestTestHandler.h
index 0153e27..9942396 100644
--- a/Source/CTest/cmCTestTestHandler.h
+++ b/Source/CTest/cmCTestTestHandler.h
@@ -43,7 +43,7 @@ public:
    * intersection or the union of the lists. By default it is the
    * intersection.
    */
-  void SetUseUnion(bool val) { m_UseUnion = val; }
+  void SetUseUnion(bool val) { this->UseUnion = val; }
 
   /**
    * This method is called when reading CTest custom file
@@ -75,16 +75,16 @@ public:
 
   struct cmCTestTestResult
   {
-    std::string m_Name;
-    std::string m_Path;
-    std::string m_FullCommandLine;
-    double      m_ExecutionTime;
-    int         m_ReturnValue;
-    int         m_Status;
-    std::string m_CompletionStatus;
-    std::string m_Output;
-    std::string m_RegressionImages;
-    int         m_TestCount;
+    std::string Name;
+    std::string Path;
+    std::string FullCommandLine;
+    double      ExecutionTime;
+    int         ReturnValue;
+    int         Status;
+    std::string CompletionStatus;
+    std::string Output;
+    std::string RegressionImages;
+    int         TestCount;
   };
 
   void Initialize();
@@ -92,13 +92,13 @@ public:
 protected:
   struct cmCTestTestProperties
   {
-    cmStdString m_Name;
-    cmStdString m_Directory;
-    std::vector<std::string> m_Args;
-    std::vector<cmsys::RegularExpression> m_ErrorRegularExpressions;
-    std::vector<cmsys::RegularExpression> m_RequiredRegularExpressions;
-    bool m_IsInBasedOnREOptions;
-    bool m_WillFail;
+    cmStdString Name;
+    cmStdString Directory;
+    std::vector<std::string> Args;
+    std::vector<cmsys::RegularExpression> ErrorRegularExpressions;
+    std::vector<cmsys::RegularExpression> RequiredRegularExpressions;
+    bool IsInBasedOnREOptions;
+    bool WillFail;
   };
 
 
@@ -107,15 +107,15 @@ protected:
   virtual void GenerateTestCommand(std::vector<const char*>& args);
   int ExecuteCommands(std::vector<cmStdString>& vec);
 
-  double                  m_ElapsedTestingTime;
+  double                  ElapsedTestingTime;
 
-  typedef std::vector<cmCTestTestResult> tm_TestResultsVector;
-  tm_TestResultsVector    m_TestResults;
+  typedef std::vector<cmCTestTestResult> TestResultsVector;
+  TestResultsVector    TestResults;
 
-  std::vector<cmStdString> m_CustomTestsIgnore;
-  std::string             m_StartTest;
-  std::string             m_EndTest;
-  bool m_MemCheck;
+  std::vector<cmStdString> CustomTestsIgnore;
+  std::string             StartTest;
+  std::string             EndTest;
+  bool MemCheck;
 
 private:
   enum { // Program statuses
@@ -144,7 +144,7 @@ private:
                         std::vector<cmStdString> &failed);
 
 
-  typedef std::vector<cmCTestTestProperties> tm_ListOfTests;
+  typedef std::vector<cmCTestTestProperties> ListOfTests;
   /**
    * Get the list of tests in directory and subdirectories.
    */
@@ -158,21 +158,21 @@ private:
   const char* GetTestStatus(int status);
   void ExpandTestsToRunInformation(int numPossibleTests);
 
-  std::vector<cmStdString> m_CustomPreTest;
-  std::vector<cmStdString> m_CustomPostTest;
+  std::vector<cmStdString> CustomPreTest;
+  std::vector<cmStdString> CustomPostTest;
 
-  int m_CustomMaximumPassedTestOutputSize;
-  int m_CustomMaximumFailedTestOutputSize;
+  int CustomMaximumPassedTestOutputSize;
+  int CustomMaximumFailedTestOutputSize;
 
-  std::vector<int>        m_TestsToRun;
+  std::vector<int>        TestsToRun;
 
-  bool m_UseIncludeRegExp;
-  bool m_UseExcludeRegExp;
-  bool m_UseExcludeRegExpFirst;
-  std::string m_IncludeRegExp;
-  std::string m_ExcludeRegExp;
-  cmsys::RegularExpression m_IncludeTestsRegularExpression;
-  cmsys::RegularExpression m_ExcludeTestsRegularExpression;
+  bool UseIncludeRegExpFlag;
+  bool UseExcludeRegExpFlag;
+  bool UseExcludeRegExpFirst;
+  std::string IncludeRegExp;
+  std::string ExcludeRegExp;
+  cmsys::RegularExpression IncludeTestsRegularExpression;
+  cmsys::RegularExpression ExcludeTestsRegularExpression;
 
   std::string GenerateRegressionImages(const std::string& xml);
 
@@ -180,11 +180,11 @@ private:
   bool CleanTestOutput(std::string& output, size_t length);
 
   std::string TestsToRunString;
-  bool m_UseUnion;
-  tm_ListOfTests m_TestList;
-  cmsys::RegularExpression m_DartStuff;
+  bool UseUnion;
+  ListOfTests TestList;
+  cmsys::RegularExpression DartStuff;
 
-  std::ostream* m_LogFile;
+  std::ostream* LogFile;
 };
 
 #endif
diff --git a/Source/CTest/cmCTestUpdateCommand.cxx b/Source/CTest/cmCTestUpdateCommand.cxx
index 04bbe93..69ddb10 100644
--- a/Source/CTest/cmCTestUpdateCommand.cxx
+++ b/Source/CTest/cmCTestUpdateCommand.cxx
@@ -69,17 +69,17 @@ bool cmCTestUpdateCommand::InitialPass(
       }
     }
 
-  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
     "UpdateCommand", "CTEST_UPDATE_COMMAND");
-  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
     "UpdateOptions", "CTEST_UPDATE_OPTIONS");
-  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
     "CVSCommand", "CTEST_CVS_COMMAND");
-  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
     "CVSUpdateOptions", "CTEST_CVS_UPDATE_OPTIONS");
-  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
     "SVNCommand", "CTEST_SVN_COMMAND");
-  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
     "SVNUpdateOptions", "CTEST_SVN_UPDATE_OPTIONS");
 
   const char* initialCheckoutCommand
@@ -89,7 +89,8 @@ bool cmCTestUpdateCommand::InitialPass(
     initialCheckoutCommand = m_Makefile->GetDefinition("CTEST_CVS_CHECKOUT");
     }
 
-  cmCTestGenericHandler* handler = m_CTest->GetInitializedHandler("update");
+  cmCTestGenericHandler* handler
+    = this->CTest->GetInitializedHandler("update");
   if ( !handler )
     {
     this->SetError("internal CTest error. Cannot instantiate update handler");
diff --git a/Source/CTest/cmCTestUpdateCommand.h b/Source/CTest/cmCTestUpdateCommand.h
index 1cb6672..cad95c4 100644
--- a/Source/CTest/cmCTestUpdateCommand.h
+++ b/Source/CTest/cmCTestUpdateCommand.h
@@ -36,8 +36,8 @@ public:
   virtual cmCommand* Clone()
     {
     cmCTestUpdateCommand* ni = new cmCTestUpdateCommand;
-    ni->m_CTest = this->m_CTest;
-    ni->m_CTestScriptHandler = this->m_CTestScriptHandler;
+    ni->CTest = this->CTest;
+    ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
     }
 
diff --git a/Source/CTest/cmCTestUpdateHandler.cxx b/Source/CTest/cmCTestUpdateHandler.cxx
index 855dcad..b14ece5 100644
--- a/Source/CTest/cmCTestUpdateHandler.cxx
+++ b/Source/CTest/cmCTestUpdateHandler.cxx
@@ -9,8 +9,8 @@
   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
 
-     This software is distributed WITHOUT ANY WARRANTY; without even 
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
      PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
@@ -34,7 +34,7 @@
 #include "windows.h"
 #endif
 
-#include <stdlib.h> 
+#include <stdlib.h>
 #include <math.h>
 #include <float.h>
 
@@ -63,22 +63,22 @@ class cmCTestUpdateHandlerSVNXMLParser : public cmXMLParser
 public:
   struct t_CommitLog
     {
-    int m_Revision;
-    std::string m_Author;
-    std::string m_Date;
-    std::string m_Message;
+    int Revision;
+    std::string Author;
+    std::string Date;
+    std::string Message;
     };
   cmCTestUpdateHandlerSVNXMLParser(cmCTestUpdateHandler* up)
-    : cmXMLParser(), m_UpdateHandler(up), m_MinRevision(-1), m_MaxRevision(-1)
+    : cmXMLParser(), UpdateHandler(up), MinRevision(-1), MaxRevision(-1)
     {
     }
 
   int Parse(const char* str)
     {
-    m_MinRevision = -1;
-    m_MaxRevision = -1;
+    this->MinRevision = -1;
+    this->MaxRevision = -1;
     int res = this->cmXMLParser::Parse(str);
-    if ( m_MinRevision == -1 || m_MaxRevision == -1 )
+    if ( this->MinRevision == -1 || this->MaxRevision == -1 )
       {
       return 0;
       }
@@ -87,63 +87,68 @@ public:
 
   typedef std::vector<t_CommitLog> t_VectorOfCommits;
 
-  t_VectorOfCommits* GetCommits() { return &m_Commits; }
-  int GetMinRevision() { return m_MinRevision; }
-  int GetMaxRevision() { return m_MaxRevision; }
+  t_VectorOfCommits* GetCommits() { return &this->Commits; }
+  int GetMinRevision() { return this->MinRevision; }
+  int GetMaxRevision() { return this->MaxRevision; }
 
 protected:
   void StartElement(const char* name, const char** atts)
     {
     if ( strcmp(name, "logentry") == 0 )
       {
-      m_CommitLog = t_CommitLog();
+      this->CommitLog = t_CommitLog();
       const char* rev = this->FindAttribute(atts, "revision");
       if ( rev)
         {
-        m_CommitLog.m_Revision = atoi(rev);
-        if ( m_MinRevision < 0 || m_MinRevision > m_CommitLog.m_Revision )
+        this->CommitLog.Revision = atoi(rev);
+        if ( this->MinRevision < 0 ||
+          this->MinRevision > this->CommitLog.Revision )
           {
-          m_MinRevision = m_CommitLog.m_Revision;
+          this->MinRevision = this->CommitLog.Revision;
           }
-        if ( m_MaxRevision < 0 || m_MaxRevision < m_CommitLog.m_Revision )
+        if ( this->MaxRevision < 0 ||
+          this->MaxRevision < this->CommitLog.Revision )
           {
-          m_MaxRevision = m_CommitLog.m_Revision;
+          this->MaxRevision = this->CommitLog.Revision;
           }
         }
       }
-    m_CharacterData.erase(m_CharacterData.begin(), m_CharacterData.end());
+    this->CharacterData.erase(
+      this->CharacterData.begin(), this->CharacterData.end());
     }
   void EndElement(const char* name)
     {
     if ( strcmp(name, "logentry") == 0 )
       {
-      cmCTestLog(m_UpdateHandler->GetCTestInstance(), HANDLER_VERBOSE_OUTPUT,
-        "\tRevision: " << m_CommitLog.m_Revision<< std::endl
-        << "\tAuthor:   " << m_CommitLog.m_Author.c_str() << std::endl
-        << "\tDate:     " << m_CommitLog.m_Date.c_str() << std::endl
-        << "\tMessage:  " << m_CommitLog.m_Message.c_str() << std::endl);
-      m_Commits.push_back(m_CommitLog);
+      cmCTestLog(this->UpdateHandler->GetCTestInstance(),
+        HANDLER_VERBOSE_OUTPUT,
+        "\tRevision: " << this->CommitLog.Revision<< std::endl
+        << "\tAuthor:   " << this->CommitLog.Author.c_str() << std::endl
+        << "\tDate:     " << this->CommitLog.Date.c_str() << std::endl
+        << "\tMessage:  " << this->CommitLog.Message.c_str() << std::endl);
+      this->Commits.push_back(this->CommitLog);
       }
     else if ( strcmp(name, "author") == 0 )
       {
-      m_CommitLog.m_Author.assign(&(*(m_CharacterData.begin())),
-        m_CharacterData.size());
+      this->CommitLog.Author.assign(&(*(this->CharacterData.begin())),
+        this->CharacterData.size());
       }
     else if ( strcmp(name, "date") == 0 )
       {
-      m_CommitLog.m_Date.assign(&(*(m_CharacterData.begin())),
-        m_CharacterData.size());
+      this->CommitLog.Date.assign(&(*(this->CharacterData.begin())),
+        this->CharacterData.size());
       }
     else if ( strcmp(name, "msg") == 0 )
       {
-      m_CommitLog.m_Message.assign(&(*(m_CharacterData.begin())),
-        m_CharacterData.size());
+      this->CommitLog.Message.assign(&(*(this->CharacterData.begin())),
+        this->CharacterData.size());
       }
-    m_CharacterData.erase(m_CharacterData.begin(), m_CharacterData.end());
+    this->CharacterData.erase(this->CharacterData.begin(),
+      this->CharacterData.end());
     }
   void CharacterDataHandler(const char* data, int length)
     {
-    m_CharacterData.insert(m_CharacterData.end(), data, data+length);
+    this->CharacterData.insert(this->CharacterData.end(), data, data+length);
     }
   const char* FindAttribute( const char** atts, const char* attribute )
     {
@@ -164,13 +169,13 @@ protected:
     }
 
 private:
-  std::vector<char> m_CharacterData;
-  cmCTestUpdateHandler* m_UpdateHandler;
-  t_CommitLog m_CommitLog;
+  std::vector<char> CharacterData;
+  cmCTestUpdateHandler* UpdateHandler;
+  t_CommitLog CommitLog;
 
-  t_VectorOfCommits m_Commits;
-  int m_MinRevision;
-  int m_MaxRevision;
+  t_VectorOfCommits Commits;
+  int MinRevision;
+  int MaxRevision;
 };
 //**********************************************************************
 //----------------------------------------------------------------------
@@ -189,11 +194,11 @@ void cmCTestUpdateHandler::Initialize()
 //----------------------------------------------------------------------
 int cmCTestUpdateHandler::DetermineType(const char* cmd, const char* type)
 {
-  cmCTestLog(m_CTest, DEBUG, "Determine update type from command: " << cmd
+  cmCTestLog(this->CTest, DEBUG, "Determine update type from command: " << cmd
     << " and type: " << type << std::endl);
   if ( type && *type )
     {
-    cmCTestLog(m_CTest, DEBUG, "Type specified: " << type << std::endl);
+    cmCTestLog(this->CTest, DEBUG, "Type specified: " << type << std::endl);
     std::string stype = cmSystemTools::LowerCase(type);
     if ( stype.find("cvs") != std::string::npos )
       {
@@ -206,8 +211,8 @@ int cmCTestUpdateHandler::DetermineType(const char* cmd, const char* type)
     }
   else
     {
-    cmCTestLog(m_CTest, DEBUG, "Type not specified, check command: " << cmd
-      << std::endl);
+    cmCTestLog(this->CTest, DEBUG, "Type not specified, check command: "
+      << cmd << std::endl);
     std::string stype = cmSystemTools::LowerCase(cmd);
     if ( stype.find("cvs") != std::string::npos )
       {
@@ -219,8 +224,8 @@ int cmCTestUpdateHandler::DetermineType(const char* cmd, const char* type)
       }
     }
   std::string sourceDirectory = this->GetOption("SourceDirectory");
-  cmCTestLog(m_CTest, DEBUG, "Check directory: " << sourceDirectory.c_str()
-    << std::endl);
+  cmCTestLog(this->CTest, DEBUG, "Check directory: "
+    << sourceDirectory.c_str() << std::endl);
   sourceDirectory += "/.svn";
   if ( cmSystemTools::FileExists(sourceDirectory.c_str()) )
     {
@@ -254,50 +259,52 @@ int cmCTestUpdateHandler::ProcessHandler()
   const char* sourceDirectory = this->GetOption("SourceDirectory");
   if ( !sourceDirectory )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE,
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
       "Cannot find SourceDirectory  key in the DartConfiguration.tcl"
       << std::endl);
     return -1;
     }
 
   cmGeneratedFileStream ofs;
-  if ( !m_CTest->GetShowOnly() )
+  if ( !this->CTest->GetShowOnly() )
     {
     this->StartLogFile("Update", ofs);
     }
 
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "Updating the repository" << std::endl);
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
+    "Updating the repository" << std::endl);
 
   const char* initialCheckoutCommand = this->GetOption("InitialCheckout");
   if ( initialCheckoutCommand )
     {
-    cmCTestLog(m_CTest, HANDLER_OUTPUT,
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
       "   First perform the initil checkout: " << initialCheckoutCommand
       << std::endl);
     cmStdString parent = cmSystemTools::GetParentDirectory(sourceDirectory);
     if ( parent.empty() )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "Something went wrong when trying "
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+        "Something went wrong when trying "
         "to determine the parent directory of " << sourceDirectory
         << std::endl);
       return -1;
       }
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Perform checkout in directory: "
-      << parent.c_str() << std::endl);
+    cmCTestLog(this->CTest, HANDLER_OUTPUT,
+      "   Perform checkout in directory: " << parent.c_str() << std::endl);
     if ( !cmSystemTools::MakeDirectory(parent.c_str()) )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE,
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
         "Cannot create parent directory: " << parent.c_str()
         << " of the source directory: " << sourceDirectory << std::endl);
       return -1;
       }
     ofs << "* Run initial checkout" << std::endl;
     ofs << "  Command: " << initialCheckoutCommand << std::endl;
-    cmCTestLog(m_CTest, DEBUG, "   Before: "
+    cmCTestLog(this->CTest, DEBUG, "   Before: "
       << initialCheckoutCommand << std::endl);
-    bool retic = m_CTest->RunCommand(initialCheckoutCommand, &goutput,
+    bool retic = this->CTest->RunCommand(initialCheckoutCommand, &goutput,
       &errors, &retVal, parent.c_str(), 0 /* Timeout */);
-    cmCTestLog(m_CTest, DEBUG, "   After: "
+    cmCTestLog(this->CTest, DEBUG, "   After: "
       << initialCheckoutCommand << std::endl);
     ofs << "  Output: " << goutput.c_str() << std::endl;
     ofs << "  Errors: " << errors.c_str() << std::endl;
@@ -306,26 +313,27 @@ int cmCTestUpdateHandler::ProcessHandler()
       cmOStringStream ostr;
       ostr << "Problem running initial checkout Output [" << goutput
         << "] Errors [" << errors << "]";
-      cmCTestLog(m_CTest, ERROR_MESSAGE, ostr.str().c_str() << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE, ostr.str().c_str() << std::endl);
       checkoutErrorMessages += ostr.str();
       updateProducedError = true;
       }
-    m_CTest->InitializeFromCommand(m_Command);
+    this->CTest->InitializeFromCommand(this->Command);
     }
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Updating the repository: "
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Updating the repository: "
     << sourceDirectory << std::endl);
 
   // Get update command
-  std::string updateCommand = m_CTest->GetCTestConfiguration("UpdateCommand");
+  std::string updateCommand
+    = this->CTest->GetCTestConfiguration("UpdateCommand");
   if ( updateCommand.empty() )
     {
-    updateCommand = m_CTest->GetCTestConfiguration("CVSCommand");
+    updateCommand = this->CTest->GetCTestConfiguration("CVSCommand");
     if ( updateCommand.empty() )
       {
-      updateCommand = m_CTest->GetCTestConfiguration("SVNCommand");
+      updateCommand = this->CTest->GetCTestConfiguration("SVNCommand");
       if ( updateCommand.empty() )
         {
-        cmCTestLog(m_CTest, ERROR_MESSAGE,
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
           "Cannot find CVSCommand, SVNCommand, or UpdateCommand key in the "
           "DartConfiguration.tcl" << std::endl);
         return -1;
@@ -343,39 +351,40 @@ int cmCTestUpdateHandler::ProcessHandler()
   else
     {
     updateType = this->DetermineType(updateCommand.c_str(),
-      m_CTest->GetCTestConfiguration("UpdateType").c_str());
+      this->CTest->GetCTestConfiguration("UpdateType").c_str());
     }
 
-  cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Use "
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Use "
     << cmCTestUpdateHandlerUpdateToString(updateType) << " repository type"
     << std::endl;);
 
   // And update options
-  std::string updateOptions = m_CTest->GetCTestConfiguration("UpdateOptions");
+  std::string updateOptions
+    = this->CTest->GetCTestConfiguration("UpdateOptions");
   if ( updateOptions.empty() )
     {
     switch (updateType)
       {
     case cmCTestUpdateHandler::e_CVS:
-      updateOptions = m_CTest->GetCTestConfiguration("CVSUpdateOptions");
+      updateOptions = this->CTest->GetCTestConfiguration("CVSUpdateOptions");
       if ( updateOptions.empty() )
         {
         updateOptions = "-dP";
         }
       break;
     case cmCTestUpdateHandler::e_SVN:
-      updateOptions = m_CTest->GetCTestConfiguration("SVNUpdateOptions");
+      updateOptions = this->CTest->GetCTestConfiguration("SVNUpdateOptions");
       break;
       }
     }
 
   // Get update time
   std::string extra_update_opts;
-  if ( m_CTest->GetTestModel() == cmCTest::NIGHTLY )
+  if ( this->CTest->GetTestModel() == cmCTest::NIGHTLY )
     {
-    struct tm* t = m_CTest->GetNightlyTime(
-      m_CTest->GetCTestConfiguration("NightlyStartTime"),
-      m_CTest->GetTomorrowTag());
+    struct tm* t = this->CTest->GetNightlyTime(
+      this->CTest->GetCTestConfiguration("NightlyStartTime"),
+      this->CTest->GetTomorrowTag());
     char current_time[1024];
     sprintf(current_time, "%04d-%02d-%02d %02d:%02d:%02d",
       t->tm_year + 1900,
@@ -427,14 +436,14 @@ int cmCTestUpdateHandler::ProcessHandler()
   //
   if ( !command.empty() )
     {
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT,
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
         "* Get repository information: " << command.c_str() << std::endl);
-    if ( !m_CTest->GetShowOnly() )
+    if ( !this->CTest->GetShowOnly() )
       {
       ofs << "* Get repository information" << std::endl;
       ofs << "  Command: " << command.c_str() << std::endl;
-      res = m_CTest->RunCommand(command.c_str(), &goutput, &errors,
-        &retVal, sourceDirectory, 0 /*m_TimeOut*/);
+      res = this->CTest->RunCommand(command.c_str(), &goutput, &errors,
+        &retVal, sourceDirectory, 0 /*this->TimeOut*/);
 
       ofs << "  Output: " << goutput.c_str() << std::endl;
       ofs << "  Errors: " << errors.c_str() << std::endl;
@@ -457,7 +466,7 @@ int cmCTestUpdateHandler::ProcessHandler()
             std::string currentRevisionString
               = current_revision_regex.match(1);
             svn_current_revision = atoi(currentRevisionString.c_str());
-            cmCTestLog(m_CTest, HANDLER_OUTPUT,
+            cmCTestLog(this->CTest, HANDLER_OUTPUT,
               "   Old revision of repository is: " << svn_current_revision
               << std::endl);
             }
@@ -467,7 +476,7 @@ int cmCTestUpdateHandler::ProcessHandler()
       }
     else
       {
-      cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT,
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
         "Update with command: " << command << std::endl);
       }
     }
@@ -475,18 +484,19 @@ int cmCTestUpdateHandler::ProcessHandler()
 
   //
   // Now update repository and remember what files were updated
-  // 
-  cmGeneratedFileStream os; 
+  //
+  cmGeneratedFileStream os;
   if ( !this->StartResultingXML("Update", os) )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open log file" << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open log file"
+      << std::endl);
     }
-  std::string start_time = m_CTest->CurrentTime();
+  std::string start_time = this->CTest->CurrentTime();
   double elapsed_time_start = cmSystemTools::GetTime();
 
-  cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "* Update repository: "
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "* Update repository: "
     << command.c_str() << std::endl);
-  if ( !m_CTest->GetShowOnly() )
+  if ( !this->CTest->GetShowOnly() )
     {
     command = "";
     switch( updateType )
@@ -496,8 +506,8 @@ int cmCTestUpdateHandler::ProcessHandler()
         " " + extra_update_opts;
       ofs << "* Update repository: " << std::endl;
       ofs << "  Command: " << command.c_str() << std::endl;
-      res = m_CTest->RunCommand(command.c_str(), &goutput, &errors,
-        &retVal, sourceDirectory, 0 /*m_TimeOut*/);
+      res = this->CTest->RunCommand(command.c_str(), &goutput, &errors,
+        &retVal, sourceDirectory, 0 /*this->TimeOut*/);
       ofs << "  Output: " << goutput.c_str() << std::endl;
       ofs << "  Errors: " << errors.c_str() << std::endl;
       break;
@@ -508,17 +518,17 @@ int cmCTestUpdateHandler::ProcessHandler()
           " " + extra_update_opts;
         ofs << "* Update repository: " << std::endl;
         ofs << "  Command: " << command.c_str() << std::endl;
-        bool res1 = m_CTest->RunCommand(command.c_str(), &partialOutput,
+        bool res1 = this->CTest->RunCommand(command.c_str(), &partialOutput,
           &errors,
-          &retVal, sourceDirectory, 0 /*m_TimeOut*/);
+          &retVal, sourceDirectory, 0 /*this->TimeOut*/);
         ofs << "  Output: " << partialOutput.c_str() << std::endl;
         ofs << "  Errors: " << errors.c_str() << std::endl;
         goutput = partialOutput;
         command = updateCommand + " status";
         ofs << "* Status repository: " << std::endl;
         ofs << "  Command: " << command.c_str() << std::endl;
-        res = m_CTest->RunCommand(command.c_str(), &partialOutput, &errors,
-          &retVal, sourceDirectory, 0 /*m_TimeOut*/);
+        res = this->CTest->RunCommand(command.c_str(), &partialOutput,
+          &errors, &retVal, sourceDirectory, 0 /*this->TimeOut*/);
         ofs << "  Output: " << partialOutput.c_str() << std::endl;
         ofs << "  Errors: " << errors.c_str() << std::endl;
         goutput += partialOutput;
@@ -541,15 +551,15 @@ int cmCTestUpdateHandler::ProcessHandler()
   os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
     << "<Update mode=\"Client\" Generator=\"ctest-"
     << cmVersion::GetCMakeVersion() << "\">\n"
-    << "\t<Site>" << m_CTest->GetCTestConfiguration("Site") << "</Site>\n"
-    << "\t<BuildName>" << m_CTest->GetCTestConfiguration("BuildName")
+    << "\t<Site>" << this->CTest->GetCTestConfiguration("Site") << "</Site>\n"
+    << "\t<BuildName>" << this->CTest->GetCTestConfiguration("BuildName")
     << "</BuildName>\n"
-    << "\t<BuildStamp>" << m_CTest->GetCurrentTag() << "-"
-    << m_CTest->GetTestModelString() << "</BuildStamp>" << std::endl;
+    << "\t<BuildStamp>" << this->CTest->GetCurrentTag() << "-"
+    << this->CTest->GetTestModelString() << "</BuildStamp>" << std::endl;
   os << "\t<StartDateTime>" << start_time << "</StartDateTime>\n"
-    << "\t<UpdateCommand>" << m_CTest->MakeXMLSafe(command)
+    << "\t<UpdateCommand>" << this->CTest->MakeXMLSafe(command)
     << "</UpdateCommand>\n"
-    << "\t<UpdateType>" << m_CTest->MakeXMLSafe(
+    << "\t<UpdateType>" << this->CTest->MakeXMLSafe(
       cmCTestUpdateHandlerUpdateToString(updateType))
     << "</UpdateType>\n";
 
@@ -584,9 +594,9 @@ int cmCTestUpdateHandler::ProcessHandler()
   bool first_file = true;
 
   cmCTestUpdateHandler::AuthorsToUpdatesMap authors_files_map;
-  int num_updated = 0;
-  int num_modified = 0;
-  int num_conflicting = 0;
+  int numUpdated = 0;
+  int numModiefied = 0;
+  int numConflicting = 0;
   // In subversion, get the latest revision
   if ( updateType == cmCTestUpdateHandler::e_SVN )
     {
@@ -601,19 +611,20 @@ int cmCTestUpdateHandler::ProcessHandler()
       }
     if ( svn_latest_revision <= 0 )
       {
-      cmCTestLog(m_CTest, ERROR_MESSAGE, "Problem determining the current "
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+        "Problem determining the current "
         "revision of the repository from output:" << std::endl
         << goutput.c_str() << std::endl);
       }
     else
       {
-      cmCTestLog(m_CTest, HANDLER_OUTPUT,
+      cmCTestLog(this->CTest, HANDLER_OUTPUT,
         "   Current revision of repository is: " << svn_latest_revision
         << std::endl);
       }
     }
 
-  cmCTestLog(m_CTest, HANDLER_OUTPUT,
+  cmCTestLog(this->CTest, HANDLER_OUTPUT,
     "   Gathering version information (each . represents one updated file):"
     << std::endl);
   int file_count = 0;
@@ -630,9 +641,9 @@ int cmCTestUpdateHandler::ProcessHandler()
       {
       if ( file_count == 0 )
         {
-        cmCTestLog(m_CTest, HANDLER_OUTPUT, "    " << std::flush);
+        cmCTestLog(this->CTest, HANDLER_OUTPUT, "    " << std::flush);
         }
-      cmCTestLog(m_CTest, HANDLER_OUTPUT, "." << std::flush);
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "." << std::flush);
       std::string upChar = file_update_line.match(1);
       std::string upFile = file_update_line.match(2);
       char mod = upChar[0];
@@ -647,7 +658,7 @@ int cmCTestUpdateHandler::ProcessHandler()
         modifiedOrConflict = true;
         }
       const char* file = upFile.c_str();
-      cmCTestLog(m_CTest, DEBUG, "Line" << cc << ": " << mod << " - "
+      cmCTestLog(this->CTest, DEBUG, "Line" << cc << ": " << mod << " - "
         << file << std::endl);
 
       std::string output;
@@ -677,14 +688,14 @@ int cmCTestUpdateHandler::ProcessHandler()
             }
           break;
           }
-        cmCTestLog(m_CTest, DEBUG, "Do log: " << logcommand << std::endl);
-        cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT,
+        cmCTestLog(this->CTest, DEBUG, "Do log: " << logcommand << std::endl);
+        cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
           "* Get file update information: " << logcommand.c_str()
           << std::endl);
         ofs << "* Get log information for file: " << file << std::endl;
         ofs << "  Command: " << logcommand.c_str() << std::endl;
-        res = m_CTest->RunCommand(logcommand.c_str(), &output, &errors,
-          &retVal, sourceDirectory, 0 /*m_TimeOut*/);
+        res = this->CTest->RunCommand(logcommand.c_str(), &output, &errors,
+          &retVal, sourceDirectory, 0 /*this->TimeOut*/);
         ofs << "  Output: " << output.c_str() << std::endl;
         ofs << "  Errors: " << errors.c_str() << std::endl;
         if ( ofs )
@@ -694,7 +705,7 @@ int cmCTestUpdateHandler::ProcessHandler()
         }
       if ( res && retVal == 0)
         {
-        cmCTestLog(m_CTest, DEBUG, output << std::endl);
+        cmCTestLog(this->CTest, DEBUG, output << std::endl);
         std::string::size_type sline = 0;
         std::string srevision1 = "Unknown";
         std::string sdate1     = "Unknown";
@@ -778,13 +789,13 @@ int cmCTestUpdateHandler::ProcessHandler()
             srevision1 = str.str();
             if (!svn_status_line_regex.find(output))
               {
-              cmCTestLog(m_CTest, ERROR_MESSAGE,
+              cmCTestLog(this->CTest, ERROR_MESSAGE,
                 "Bad output from SVN status command: " << output
                 << std::endl);
               }
             else if ( svn_status_line_regex.match(4) != file )
               {
-              cmCTestLog(m_CTest, ERROR_MESSAGE,
+              cmCTestLog(this->CTest, ERROR_MESSAGE,
                 "Bad output from SVN status command. "
                 "The file name returned: \""
                 << svn_status_line_regex.match(4)
@@ -812,27 +823,27 @@ int cmCTestUpdateHandler::ProcessHandler()
               int maxrev = parser.GetMaxRevision();
               cmCTestUpdateHandlerSVNXMLParser::
                 t_VectorOfCommits::iterator it;
-              for ( it = parser.GetCommits()->begin(); 
-                it != parser.GetCommits()->end(); 
+              for ( it = parser.GetCommits()->begin();
+                it != parser.GetCommits()->end();
                 ++ it )
                 {
-                if ( it->m_Revision == maxrev )
+                if ( it->Revision == maxrev )
                   {
                   cmOStringStream mRevStream;
                   mRevStream << maxrev;
                   srevision1 = mRevStream.str();
-                  sauthor1 = it->m_Author;
-                  comment1 = it->m_Message;
-                  sdate1 = it->m_Date;
+                  sauthor1 = it->Author;
+                  comment1 = it->Message;
+                  sdate1 = it->Date;
                   }
-                else if ( it->m_Revision == minrev )
+                else if ( it->Revision == minrev )
                   {
                   cmOStringStream mRevStream;
                   mRevStream << minrev;
                   srevision2 = mRevStream.str();
-                  sauthor2 = it->m_Author;
-                  comment2 = it->m_Message;       
-                  sdate2 = it->m_Date;
+                  sauthor2 = it->Author;
+                  comment2 = it->Message;
+                  sdate2 = it->Date;
                   }
                 }
               }
@@ -869,30 +880,30 @@ int cmCTestUpdateHandler::ProcessHandler()
           }
         if ( mod == 'C' )
           {
-          num_conflicting ++;
+          numConflicting ++;
           os << "\t<Conflicting>" << std::endl;
           }
         else if ( mod == 'G' )
           {
-          num_conflicting ++;
+          numConflicting ++;
           os << "\t<Conflicting>" << std::endl;
           }
         else if ( mod == 'M' )
           {
-          num_modified ++;
+          numModiefied ++;
           os << "\t<Modified>" << std::endl;
           }
         else
           {
-          num_updated ++;
+          numUpdated ++;
           os << "\t<Updated>" << std::endl;
           }
         if ( srevision2 == "Unknown" )
           {
           srevision2 = srevision1;
           }
-        cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "File: " << path.c_str()
-          << " / " << fname.c_str() << " was updated by "
+        cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "File: "
+          << path.c_str() << " / " << fname.c_str() << " was updated by "
           << sauthor1.c_str() << " to revision: " << srevision1.c_str()
           << " from revision: " << srevision2.c_str() << std::endl);
         os << "\t\t<File Directory=\"" << cmCTest::MakeXMLSafe(path) << "\">"
@@ -968,28 +979,28 @@ int cmCTestUpdateHandler::ProcessHandler()
     }
   if ( file_count )
     {
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, std::endl);
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
     }
-  if ( num_updated )
+  if ( numUpdated )
     {
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Found " << num_updated
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Found " << numUpdated
       << " updated files" << std::endl);
     }
-  if ( num_modified )
+  if ( numModiefied )
     {
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Found " << num_modified
-      << " locally modified files" 
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Found " << numModiefied
+      << " locally modified files"
       << std::endl);
     }
-  if ( num_conflicting )
+  if ( numConflicting )
     {
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Found " << num_conflicting
-      << " conflicting files" 
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Found " << numConflicting
+      << " conflicting files"
       << std::endl);
     }
-  if ( num_modified == 0 && num_conflicting == 0 && num_updated == 0 )
+  if ( numModiefied == 0 && numConflicting == 0 && numUpdated == 0 )
     {
-    cmCTestLog(m_CTest, HANDLER_OUTPUT, "   Project is up-to-date"
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Project is up-to-date"
       << std::endl);
     }
   if ( !first_file )
@@ -1013,36 +1024,37 @@ int cmCTestUpdateHandler::ProcessHandler()
     os << "\t</Author>" << std::endl;
     }
 
-  cmCTestLog(m_CTest, DEBUG, "End" << std::endl);
-  std::string end_time = m_CTest->CurrentTime();
+  cmCTestLog(this->CTest, DEBUG, "End" << std::endl);
+  std::string end_time = this->CTest->CurrentTime();
   os << "\t<EndDateTime>" << end_time << "</EndDateTime>\n"
-    << "<ElapsedMinutes>" << 
-    static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start)/6)/10.0 
+    << "<ElapsedMinutes>" <<
+    static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start)/6)/10.0
     << "</ElapsedMinutes>\n"
     << "\t<UpdateReturnStatus>";
-  if ( num_modified > 0 || num_conflicting > 0 )
+  if ( numModiefied > 0 || numConflicting > 0 )
     {
     os << "Update error: There are modified or conflicting files in the "
       "repository";
-    cmCTestLog(m_CTest, ERROR_MESSAGE,
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
       "   There are modified or conflicting files in the repository"
       << std::endl);
     }
   if ( updateProducedError )
     {
     os << "Update error: ";
-    os << m_CTest->MakeXMLSafe(checkoutErrorMessages);
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "   Update with command: " << command
-      << " failed" << std::endl);
+    os << this->CTest->MakeXMLSafe(checkoutErrorMessages);
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "   Update with command: "
+      << command << " failed" << std::endl);
     }
   os << "</UpdateReturnStatus>" << std::endl;
   os << "</Update>" << std::endl;
 
   if (! res || retVal )
     {
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Error(s) when updating the project"
-      << std::endl);
-    cmCTestLog(m_CTest, ERROR_MESSAGE, "Output: " << goutput << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+      "Error(s) when updating the project" << std::endl);
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Output: "
+      << goutput << std::endl);
     return -1;
     }
   return count;
diff --git a/Source/CTest/cmCTestUpdateHandler.h b/Source/CTest/cmCTestUpdateHandler.h
index bcef45e..7343859 100644
--- a/Source/CTest/cmCTestUpdateHandler.h
+++ b/Source/CTest/cmCTestUpdateHandler.h
@@ -9,8 +9,8 @@
   Copyright (c) 2002 Kitware, Inc. All rights reserved.
   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
 
-     This software is distributed WITHOUT ANY WARRANTY; without even 
-     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
      PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
@@ -39,7 +39,7 @@ public:
    * The main entry point for this class
    */
   int ProcessHandler();
-  
+
   cmCTestUpdateHandler();
 
   enum {
@@ -53,13 +53,13 @@ public:
    * Initialize handler
    */
   virtual void Initialize();
-  
+
 private:
   // Some structures needed for update
-  struct StringPair : 
+  struct StringPair :
     public std::pair<std::string, std::string>{};
   struct UpdateFiles : public std::vector<StringPair>{};
-  struct AuthorsToUpdatesMap : 
+  struct AuthorsToUpdatesMap :
     public std::map<std::string, UpdateFiles>{};
 
   // Determine the type of version control