STYLE: some m_ to this-> cleanup

197 files changed, 3788 insertions, 3748 deletions

diff --git a/Source/CTest/cmCTestBuildCommand.cxx b/Source/CTest/cmCTestBuildCommand.cxx
index 91cb366..b323881 100644
--- a/Source/CTest/cmCTestBuildCommand.cxx
+++ b/Source/CTest/cmCTestBuildCommand.cxx
@@ -103,7 +103,7 @@ bool cmCTestBuildCommand::InitialPass(
     }
 
   const char* ctestBuildCommand
-    = m_Makefile->GetDefinition("CTEST_BUILD_COMMAND");
+    = this->Makefile->GetDefinition("CTEST_BUILD_COMMAND");
   if ( ctestBuildCommand && *ctestBuildCommand )
     {
     this->CTest->SetCTestConfiguration("MakeCommand", ctestBuildCommand);
@@ -111,13 +111,13 @@ bool cmCTestBuildCommand::InitialPass(
   else
     {
     const char* cmakeGeneratorName
-      = m_Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
+      = this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
     const char* cmakeProjectName
-      = m_Makefile->GetDefinition("CTEST_PROJECT_NAME");
+      = this->Makefile->GetDefinition("CTEST_PROJECT_NAME");
     const char* cmakeBuildConfiguration
-      = m_Makefile->GetDefinition("CTEST_BUILD_CONFIGURATION");
+      = this->Makefile->GetDefinition("CTEST_BUILD_CONFIGURATION");
     const char* cmakeBuildAdditionalFlags
-      = m_Makefile->GetDefinition("CTEST_BUILD_FLAGS");
+      = this->Makefile->GetDefinition("CTEST_BUILD_FLAGS");
     if ( cmakeGeneratorName && *cmakeGeneratorName &&
       cmakeProjectName && *cmakeProjectName )
       {
@@ -137,12 +137,12 @@ bool cmCTestBuildCommand::InitialPass(
       if ( !this->GlobalGenerator )
         {
         this->GlobalGenerator =
-          m_Makefile->GetCMakeInstance()->CreateGlobalGenerator(
+          this->Makefile->GetCMakeInstance()->CreateGlobalGenerator(
             cmakeGeneratorName);
         }
-      this->GlobalGenerator->FindMakeProgram(m_Makefile);
+      this->GlobalGenerator->FindMakeProgram(this->Makefile);
       const char* cmakeMakeProgram
-        = m_Makefile->GetDefinition("CMAKE_MAKE_PROGRAM");
+        = this->Makefile->GetDefinition("CMAKE_MAKE_PROGRAM");
       std::string buildCommand
         = this->GlobalGenerator->GenerateBuildCommand(cmakeMakeProgram,
           cmakeProjectName,
@@ -166,7 +166,7 @@ bool cmCTestBuildCommand::InitialPass(
     {
     cmOStringStream str;
     str << res;
-    m_Makefile->AddDefinition(res_var, str.str().c_str());
+    this->Makefile->AddDefinition(res_var, str.str().c_str());
     }
   return true;
 }
diff --git a/Source/CTest/cmCTestConfigureCommand.cxx b/Source/CTest/cmCTestConfigureCommand.cxx
index dd95cc0..2d5a16f 100644
--- a/Source/CTest/cmCTestConfigureCommand.cxx
+++ b/Source/CTest/cmCTestConfigureCommand.cxx
@@ -92,7 +92,7 @@ bool cmCTestConfigureCommand::InitialPass(
     }
   else
     {
-    source_dir = m_Makefile->GetDefinition("CTEST_SOURCE_DIRECTORY");
+    source_dir = this->Makefile->GetDefinition("CTEST_SOURCE_DIRECTORY");
     }
 
   if ( build_dir )
@@ -101,7 +101,7 @@ bool cmCTestConfigureCommand::InitialPass(
     }
   else
     {
-    build_dir = m_Makefile->GetDefinition("CTEST_BINARY_DIRECTORY");
+    build_dir = this->Makefile->GetDefinition("CTEST_BINARY_DIRECTORY");
     if ( !build_dir )
       {
       this->SetError("Build directory not specified. Either use BUILD "
@@ -113,7 +113,7 @@ bool cmCTestConfigureCommand::InitialPass(
 
 
   const char* ctestConfigureCommand
-    = m_Makefile->GetDefinition("CTEST_CONFIGURE_COMMAND");
+    = this->Makefile->GetDefinition("CTEST_CONFIGURE_COMMAND");
   if ( ctestConfigureCommand && *ctestConfigureCommand )
     {
     this->CTest->SetCTestConfiguration("ConfigureCommand",
@@ -122,7 +122,7 @@ bool cmCTestConfigureCommand::InitialPass(
   else
     {
     const char* cmakeGeneratorName
-      = m_Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
+      = this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
     if ( cmakeGeneratorName && *cmakeGeneratorName )
       {
       std::string cmakeConfigureCommand = "\"";
@@ -157,7 +157,7 @@ bool cmCTestConfigureCommand::InitialPass(
     {
     cmOStringStream str;
     str << res;
-    m_Makefile->AddDefinition(res_var, str.str().c_str());
+    this->Makefile->AddDefinition(res_var, str.str().c_str());
     }
   return true;
 }
diff --git a/Source/CTest/cmCTestCoverageCommand.cxx b/Source/CTest/cmCTestCoverageCommand.cxx
index 602bad1..c70c4cf 100644
--- a/Source/CTest/cmCTestCoverageCommand.cxx
+++ b/Source/CTest/cmCTestCoverageCommand.cxx
@@ -74,7 +74,7 @@ bool cmCTestCoverageCommand::InitialPass(
     this->CTest->SetCTestConfiguration("BuildDirectory", build_dir);
     }
 
-  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "CoverageCommand", "CTEST_COVERAGE_COMMAND");
 
   cmCTestGenericHandler* handler
@@ -92,7 +92,7 @@ bool cmCTestCoverageCommand::InitialPass(
     {
     cmOStringStream str;
     str << res;
-    m_Makefile->AddDefinition(res_var, str.str().c_str());
+    this->Makefile->AddDefinition(res_var, str.str().c_str());
     }
   cmSystemTools::ChangeDirectory(current_dir.c_str());
   return true;
diff --git a/Source/CTest/cmCTestHandlerCommand.cxx b/Source/CTest/cmCTestHandlerCommand.cxx
index 91bcb6c..10d58ae 100644
--- a/Source/CTest/cmCTestHandlerCommand.cxx
+++ b/Source/CTest/cmCTestHandlerCommand.cxx
@@ -81,7 +81,7 @@ bool cmCTestHandlerCommand::InitialPass(
     {
     cmOStringStream str;
     str << res;
-    m_Makefile->AddDefinition(
+    this->Makefile->AddDefinition(
       this->Values[ct_RETURN_VALUE], str.str().c_str());
     }
   cmSystemTools::ChangeDirectory(current_dir.c_str());
diff --git a/Source/CTest/cmCTestMemCheckCommand.cxx b/Source/CTest/cmCTestMemCheckCommand.cxx
index a2e33a0..2e1c084 100644
--- a/Source/CTest/cmCTestMemCheckCommand.cxx
+++ b/Source/CTest/cmCTestMemCheckCommand.cxx
@@ -25,11 +25,11 @@ cmCTestGenericHandler* cmCTestMemCheckCommand::InitializeActualHandler()
   cmCTestGenericHandler* handler
     = this->CTest->GetInitializedHandler("memcheck");
 
-  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "MemoryCheckCommand", "CTEST_MEMORYCHECK_COMMAND");
-  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "MemoryCheckCommandOptions", "CTEST_MEMORYCHECK_COMMAND_OPTIONS");
-  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "MemoryCheckSuppressionFile", "CTEST_MEMORYCHECK_SUPPRESSIONS_FILE");
 
   return handler;
diff --git a/Source/CTest/cmCTestStartCommand.cxx b/Source/CTest/cmCTestStartCommand.cxx
index 38b5cd7..515cf75 100644
--- a/Source/CTest/cmCTestStartCommand.cxx
+++ b/Source/CTest/cmCTestStartCommand.cxx
@@ -48,11 +48,11 @@ bool cmCTestStartCommand::InitialPass(
     }
   if ( !src_dir )
     {
-    src_dir = m_Makefile->GetDefinition("CTEST_SOURCE_DIRECTORY");
+    src_dir = this->Makefile->GetDefinition("CTEST_SOURCE_DIRECTORY");
     }
   if ( !bld_dir)
     {
-    bld_dir = m_Makefile->GetDefinition("CTEST_BINARY_DIRECTORY");
+    bld_dir = this->Makefile->GetDefinition("CTEST_BINARY_DIRECTORY");
     }
   if ( !src_dir )
     {
@@ -75,7 +75,7 @@ bool cmCTestStartCommand::InitialPass(
     << "   Source directory: " << src_dir << std::endl
     << "   Build directory: " << bld_dir << std::endl);
 
-  m_Makefile->AddDefinition("CTEST_RUN_CURRENT_SCRIPT", "OFF");
+  this->Makefile->AddDefinition("CTEST_RUN_CURRENT_SCRIPT", "OFF");
   this->CTest->SetSuppressUpdatingCTestConfiguration(true);
   int model = this->CTest->GetTestModelFromString(smodel);
   this->CTest->SetTestModel(model);
diff --git a/Source/CTest/cmCTestSubmitCommand.cxx b/Source/CTest/cmCTestSubmitCommand.cxx
index e28522e..5663bc4 100644
--- a/Source/CTest/cmCTestSubmitCommand.cxx
+++ b/Source/CTest/cmCTestSubmitCommand.cxx
@@ -53,13 +53,13 @@ bool cmCTestSubmitCommand::InitialPass(
     }
 
   const char* ctestDropMethod
-    = m_Makefile->GetDefinition("CTEST_DROP_METHOD");
+    = this->Makefile->GetDefinition("CTEST_DROP_METHOD");
   const char* ctestDropSite
-    = m_Makefile->GetDefinition("CTEST_DROP_SITE");
+    = this->Makefile->GetDefinition("CTEST_DROP_SITE");
   const char* ctestDropLocation
-    = m_Makefile->GetDefinition("CTEST_DROP_LOCATION");
+    = this->Makefile->GetDefinition("CTEST_DROP_LOCATION");
   const char* ctestTriggerSite
-    = m_Makefile->GetDefinition("CTEST_TRIGGER_SITE");
+    = this->Makefile->GetDefinition("CTEST_TRIGGER_SITE");
 
   if ( !ctestDropMethod )
     {
@@ -86,15 +86,15 @@ bool cmCTestSubmitCommand::InitialPass(
   this->CTest->SetCTestConfiguration("DropLocation", ctestDropLocation);
   this->CTest->SetCTestConfiguration("TriggerSite",  ctestTriggerSite);
 
-  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "DropSiteUser", "CTEST_DROP_SITE_USER");
-  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "DropSitePassword", "CTEST_DROP_SITE_PASSWORD");
-  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "ScpCommand", "CTEST_SCP_COMMAND");
 
   const char* notesFilesVariable
-    = m_Makefile->GetDefinition("CTEST_NOTES_FILES");
+    = this->Makefile->GetDefinition("CTEST_NOTES_FILES");
   if (notesFilesVariable)
     {
     std::vector<std::string> notesFiles;
@@ -110,7 +110,7 @@ bool cmCTestSubmitCommand::InitialPass(
     this->CTest->GenerateNotesFile(newNotesFiles);
     }
   const char* extraFilesVariable
-    = m_Makefile->GetDefinition("CTEST_EXTRA_SUBMIT_FILES");
+    = this->Makefile->GetDefinition("CTEST_EXTRA_SUBMIT_FILES");
   if (extraFilesVariable)
     {
     std::vector<std::string> extraFiles;
@@ -142,7 +142,7 @@ bool cmCTestSubmitCommand::InitialPass(
     {
     cmOStringStream str;
     str << res;
-    m_Makefile->AddDefinition(res_var, str.str().c_str());
+    this->Makefile->AddDefinition(res_var, str.str().c_str());
     }
   return true;
 }
diff --git a/Source/CTest/cmCTestTestCommand.cxx b/Source/CTest/cmCTestTestCommand.cxx
index f839b69..4c962e9 100644
--- a/Source/CTest/cmCTestTestCommand.cxx
+++ b/Source/CTest/cmCTestTestCommand.cxx
@@ -30,7 +30,8 @@ cmCTestTestCommand::cmCTestTestCommand()
 
 cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
 {
-  const char* ctestTimeout = m_Makefile->GetDefinition("CTEST_TEST_TIMEOUT");
+  const char* ctestTimeout = 
+    this->Makefile->GetDefinition("CTEST_TEST_TIMEOUT");
   double timeout = this->CTest->GetTimeOut();
   if ( ctestTimeout )
     {
diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx
index fe412e2..af7ed42 100644
--- a/Source/CTest/cmCTestTestHandler.cxx
+++ b/Source/CTest/cmCTestTestHandler.cxx
@@ -111,7 +111,7 @@ bool cmCTestSubdirCommand::InitialPass(std::vector<std::string> const& args)
       }
     fname += "/";
     fname += testFilename;
-    bool readit = m_Makefile->ReadListFile( m_Makefile->GetCurrentListFile(),
+    bool readit = this->Makefile->ReadListFile( this->Makefile->GetCurrentListFile(),
       fname.c_str());
     cmSystemTools::ChangeDirectory(cwd.c_str());
     if(!readit)
diff --git a/Source/CTest/cmCTestUpdateCommand.cxx b/Source/CTest/cmCTestUpdateCommand.cxx
index 69ddb10..94a79b9 100644
--- a/Source/CTest/cmCTestUpdateCommand.cxx
+++ b/Source/CTest/cmCTestUpdateCommand.cxx
@@ -69,24 +69,24 @@ bool cmCTestUpdateCommand::InitialPass(
       }
     }
 
-  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "UpdateCommand", "CTEST_UPDATE_COMMAND");
-  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "UpdateOptions", "CTEST_UPDATE_OPTIONS");
-  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "CVSCommand", "CTEST_CVS_COMMAND");
-  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "CVSUpdateOptions", "CTEST_CVS_UPDATE_OPTIONS");
-  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "SVNCommand", "CTEST_SVN_COMMAND");
-  this->CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
+  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
     "SVNUpdateOptions", "CTEST_SVN_UPDATE_OPTIONS");
 
   const char* initialCheckoutCommand
-    = m_Makefile->GetDefinition("CTEST_CHECKOUT_COMMAND");
+    = this->Makefile->GetDefinition("CTEST_CHECKOUT_COMMAND");
   if ( !initialCheckoutCommand )
     {
-    initialCheckoutCommand = m_Makefile->GetDefinition("CTEST_CVS_CHECKOUT");
+    initialCheckoutCommand = this->Makefile->GetDefinition("CTEST_CVS_CHECKOUT");
     }
 
   cmCTestGenericHandler* handler
@@ -126,7 +126,7 @@ bool cmCTestUpdateCommand::InitialPass(
     {
     cmOStringStream str;
     str << res;
-    m_Makefile->AddDefinition(res_var, str.str().c_str());
+    this->Makefile->AddDefinition(res_var, str.str().c_str());
     }
   return true;
 }
diff --git a/Source/cmAddCustomCommandCommand.cxx b/Source/cmAddCustomCommandCommand.cxx
index f8b1ea1..c056b43 100644
--- a/Source/cmAddCustomCommandCommand.cxx
+++ b/Source/cmAddCustomCommandCommand.cxx
@@ -131,7 +131,7 @@ bool cmAddCustomCommandCommand::InitialPass(
         case doing_outputs:
           if (!cmSystemTools::FileIsFullPath(copy.c_str()))
             {
-            filename = m_Makefile->GetStartDirectory();
+            filename = this->Makefile->GetStartDirectory();
             filename += "/";
             }
           filename += copy;
@@ -218,14 +218,14 @@ bool cmAddCustomCommandCommand::InitialPass(
     {
     // Source is empty, use the target.
     std::vector<std::string> no_depends;
-    m_Makefile->AddCustomCommandToTarget(target.c_str(), no_depends,
+    this->Makefile->AddCustomCommandToTarget(target.c_str(), no_depends,
                                          commandLines, cctype,
                                          comment.c_str(), working.c_str());
     }
   else if(target.empty())
     {
     // Target is empty, use the output.
-    m_Makefile->AddCustomCommandToOutput(output.c_str(), depends,
+    this->Makefile->AddCustomCommandToOutput(output.c_str(), depends,
                                          main_dependency.c_str(),
                                          commandLines, comment.c_str(),
                                          working.c_str());
@@ -233,7 +233,7 @@ bool cmAddCustomCommandCommand::InitialPass(
   else
     {
     // Use the old-style mode for backward compatibility.
-    m_Makefile->AddCustomCommandOldStyle(target.c_str(), outputs, depends,
+    this->Makefile->AddCustomCommandOldStyle(target.c_str(), outputs, depends,
                                          source.c_str(), commandLines,
                                          comment.c_str());
     }
diff --git a/Source/cmAddCustomTargetCommand.cxx b/Source/cmAddCustomTargetCommand.cxx
index 13ef987..f98ca26 100644
--- a/Source/cmAddCustomTargetCommand.cxx
+++ b/Source/cmAddCustomTargetCommand.cxx
@@ -119,9 +119,9 @@ bool cmAddCustomTargetCommand::InitialPass(
 
   // Add the utility target to the makefile.
   const char* no_output = 0;
-  m_Makefile->AddUtilityCommand(args[0].c_str(), all, no_output,
-                                working_directory.c_str(), depends,
-                                commandLines);
+  this->Makefile->AddUtilityCommand(args[0].c_str(), all, no_output,
+                                    working_directory.c_str(), depends,
+                                    commandLines);
 
   return true;
 }
diff --git a/Source/cmAddDefinitionsCommand.cxx b/Source/cmAddDefinitionsCommand.cxx
index 7034a43..d84f914 100644
--- a/Source/cmAddDefinitionsCommand.cxx
+++ b/Source/cmAddDefinitionsCommand.cxx
@@ -29,7 +29,7 @@ bool cmAddDefinitionsCommand::InitialPass(
   for(std::vector<std::string>::const_iterator i = args.begin();
       i != args.end(); ++i)
     {
-    m_Makefile->AddDefineFlag(i->c_str());
+    this->Makefile->AddDefineFlag(i->c_str());
     }
   return true;
 }
diff --git a/Source/cmAddDependenciesCommand.cxx b/Source/cmAddDependenciesCommand.cxx
index e81014d..d994073 100644
--- a/Source/cmAddDependenciesCommand.cxx
+++ b/Source/cmAddDependenciesCommand.cxx
@@ -28,7 +28,7 @@ bool cmAddDependenciesCommand::InitialPass(
 
   std::string target_name = args[0];
 
-  cmTargets &tgts = m_Makefile->GetTargets();
+  cmTargets &tgts = this->Makefile->GetTargets();
   if (tgts.find(target_name) != tgts.end())
     {
     std::vector<std::string>::const_iterator s = args.begin();
diff --git a/Source/cmAddExecutableCommand.cxx b/Source/cmAddExecutableCommand.cxx
index 71e338d..b440e03 100644
--- a/Source/cmAddExecutableCommand.cxx
+++ b/Source/cmAddExecutableCommand.cxx
@@ -56,7 +56,7 @@ bool cmAddExecutableCommand::InitialPass(std::vector<std::string> const& args)
     }
 
   std::vector<std::string> srclists(s, args.end());
-  cmTarget* tgt = m_Makefile->AddExecutable(exename.c_str(), srclists); 
+  cmTarget* tgt = this->Makefile->AddExecutable(exename.c_str(), srclists); 
   if ( use_win32 )
     {
     tgt->SetProperty("WIN32_EXECUTABLE", "ON");
diff --git a/Source/cmAddLibraryCommand.cxx b/Source/cmAddLibraryCommand.cxx
index f363b93..afcac0b 100644
--- a/Source/cmAddLibraryCommand.cxx
+++ b/Source/cmAddLibraryCommand.cxx
@@ -27,11 +27,11 @@ bool cmAddLibraryCommand::InitialPass(std::vector<std::string> const& args)
   // Library type defaults to value of BUILD_SHARED_LIBS, if it exists,
   // otherwise it defaults to static library.
   int shared = 
-    !cmSystemTools::IsOff(m_Makefile->GetDefinition("BUILD_SHARED_LIBS"));
+    !cmSystemTools::IsOff(this->Makefile->GetDefinition("BUILD_SHARED_LIBS"));
   
   std::vector<std::string>::const_iterator s = args.begin();
 
-  m_LibName = *s;
+  this->LibName = *s;
 
   ++s;
   
@@ -74,7 +74,7 @@ bool cmAddLibraryCommand::InitialPass(std::vector<std::string> const& args)
     ++s;
     }
 
-  m_Makefile->AddLibrary(m_LibName.c_str(), shared, srclists);
+  this->Makefile->AddLibrary(this->LibName.c_str(), shared, srclists);
   
   return true;
 }
diff --git a/Source/cmAddLibraryCommand.h b/Source/cmAddLibraryCommand.h
index 4c41599..86a9eb9 100644
--- a/Source/cmAddLibraryCommand.h
+++ b/Source/cmAddLibraryCommand.h
@@ -75,7 +75,7 @@ public:
   cmTypeMacro(cmAddLibraryCommand, cmCommand);
 
 private:
-  std::string m_LibName;
+  std::string LibName;
 };
 
 
diff --git a/Source/cmAddSubDirectoryCommand.cxx b/Source/cmAddSubDirectoryCommand.cxx
index 9e56c12..a134c59 100644
--- a/Source/cmAddSubDirectoryCommand.cxx
+++ b/Source/cmAddSubDirectoryCommand.cxx
@@ -55,7 +55,7 @@ bool cmAddSubDirectoryCommand::InitialPass(std::vector<std::string> const& args)
   // check for relative arguments
   bool relativeSource = true;
   std::string binPath = binArg;
-  std::string srcPath = std::string(m_Makefile->GetCurrentDirectory()) + 
+  std::string srcPath = std::string(this->Makefile->GetCurrentDirectory()) + 
     "/" + srcArg;
   // if the path does not exist then the arg was relative
   if (!cmSystemTools::FileIsDirectory(srcPath.c_str()))
@@ -79,7 +79,7 @@ bool cmAddSubDirectoryCommand::InitialPass(std::vector<std::string> const& args)
     {
     if (!cmSystemTools::FileIsFullPath(binPath.c_str()))
       {
-      binPath = std::string(m_Makefile->GetCurrentOutputDirectory()) + 
+      binPath = std::string(this->Makefile->GetCurrentOutputDirectory()) + 
         "/" + binArg.c_str();
       }
     }
@@ -89,7 +89,7 @@ bool cmAddSubDirectoryCommand::InitialPass(std::vector<std::string> const& args)
     // if the srcArg was relative then we just do the same for the binPath
     if (relativeSource)
       {
-      binPath = std::string(m_Makefile->GetCurrentOutputDirectory()) + 
+      binPath = std::string(this->Makefile->GetCurrentOutputDirectory()) + 
         "/" + srcArg;
       }
     // otherwise we try to remove the CurrentDirectory from the srcPath and
@@ -101,18 +101,18 @@ bool cmAddSubDirectoryCommand::InitialPass(std::vector<std::string> const& args)
       // try replacing the home dir with the home output dir
       binPath = srcPath;
       if (!cmSystemTools::FindLastString(binPath.c_str(), 
-                                         m_Makefile->GetHomeDirectory()))
+                                         this->Makefile->GetHomeDirectory()))
         {
         this->SetError("A full source directory was specified that is not in the source tree but no binary directory was specified. If you specify an out of tree source directory then you must provide the binary directory as well.");   
         return false;
         }
-      cmSystemTools::ReplaceString(binPath,m_Makefile->GetHomeDirectory(), 
-                                   m_Makefile->GetHomeOutputDirectory());
+      cmSystemTools::ReplaceString(binPath,this->Makefile->GetHomeDirectory(), 
+                                   this->Makefile->GetHomeOutputDirectory());
       }
     }
   
   // now we have all the arguments
-  m_Makefile->AddSubDirectory(srcPath.c_str(), binPath.c_str(),
+  this->Makefile->AddSubDirectory(srcPath.c_str(), binPath.c_str(),
                               intoplevel, false, true);
 
   return true;
diff --git a/Source/cmAddTestCommand.cxx b/Source/cmAddTestCommand.cxx
index 0c11851..00cda18 100644
--- a/Source/cmAddTestCommand.cxx
+++ b/Source/cmAddTestCommand.cxx
@@ -42,7 +42,7 @@ bool cmAddTestCommand::InitialPass(std::vector<std::string> const& args)
     arguments.push_back(*it);
     }
 
-  cmTest* test = m_Makefile->CreateTest(args[0].c_str());
+  cmTest* test = this->Makefile->CreateTest(args[0].c_str());
   test->SetCommand(args[1].c_str());
   test->SetArguments(arguments);
 
diff --git a/Source/cmAuxSourceDirectoryCommand.cxx b/Source/cmAuxSourceDirectoryCommand.cxx
index da9259e..892ed4a 100644
--- a/Source/cmAuxSourceDirectoryCommand.cxx
+++ b/Source/cmAuxSourceDirectoryCommand.cxx
@@ -30,13 +30,13 @@ bool cmAuxSourceDirectoryCommand::InitialPass(std::vector<std::string> const& ar
   
   std::string sourceListValue;
   std::string templateDirectory = args[0];
-  m_Makefile->AddExtraDirectory(templateDirectory.c_str());
-  std::string tdir = m_Makefile->GetCurrentDirectory();
+  this->Makefile->AddExtraDirectory(templateDirectory.c_str());
+  std::string tdir = this->Makefile->GetCurrentDirectory();
   tdir += "/";
   tdir += templateDirectory;
 
   // was the list already populated
-  const char *def = m_Makefile->GetDefinition(args[1].c_str());  
+  const char *def = this->Makefile->GetDefinition(args[1].c_str());  
   if (def)
     {
     sourceListValue = def;
@@ -58,9 +58,9 @@ bool cmAuxSourceDirectoryCommand::InitialPass(std::vector<std::string> const& ar
         file = file.substr(0, dotpos);
         // Process only source files
         if( file.size() != 0
-            && std::find( m_Makefile->GetSourceExtensions().begin(),
-                          m_Makefile->GetSourceExtensions().end(), ext )
-                 != m_Makefile->GetSourceExtensions().end() )
+            && std::find( this->Makefile->GetSourceExtensions().begin(),
+                          this->Makefile->GetSourceExtensions().end(), ext )
+                 != this->Makefile->GetSourceExtensions().end() )
           {
           std::string fullname = templateDirectory;
           fullname += "/";
@@ -68,11 +68,11 @@ bool cmAuxSourceDirectoryCommand::InitialPass(std::vector<std::string> const& ar
           // add the file as a class file so 
           // depends can be done
           cmSourceFile cmfile;
-          cmfile.SetName(fullname.c_str(), m_Makefile->GetCurrentDirectory(),
-                         m_Makefile->GetSourceExtensions(),
-                         m_Makefile->GetHeaderExtensions());
+          cmfile.SetName(fullname.c_str(), this->Makefile->GetCurrentDirectory(),
+                         this->Makefile->GetSourceExtensions(),
+                         this->Makefile->GetHeaderExtensions());
           cmfile.SetProperty("ABSTRACT","0");
-          m_Makefile->AddSource(cmfile);
+          this->Makefile->AddSource(cmfile);
           if (sourceListValue.size() > 0)
             {
             sourceListValue += ";";
@@ -84,7 +84,7 @@ bool cmAuxSourceDirectoryCommand::InitialPass(std::vector<std::string> const& ar
         }
       }
     }
-  m_Makefile->AddDefinition(args[1].c_str(), sourceListValue.c_str());  
+  this->Makefile->AddDefinition(args[1].c_str(), sourceListValue.c_str());  
   return true;
 }
 
diff --git a/Source/cmBuildCommand.cxx b/Source/cmBuildCommand.cxx
index 745583c..13443b0 100644
--- a/Source/cmBuildCommand.cxx
+++ b/Source/cmBuildCommand.cxx
@@ -29,19 +29,18 @@ bool cmBuildCommand::InitialPass(std::vector<std::string> const& args)
     }
   const char* define = args[0].c_str();
   const char* cacheValue
-    = m_Makefile->GetDefinition(define);
+    = this->Makefile->GetDefinition(define);
   std::string makeprogram = args[1];
-  std::string makecommand
-    = m_Makefile->GetLocalGenerator()
-    ->GetGlobalGenerator()->GenerateBuildCommand(
-      makeprogram.c_str(), m_Makefile->GetProjectName(), 0,
-    0, "Release", true);
+  std::string makecommand = this->Makefile->GetLocalGenerator()
+    ->GetGlobalGenerator()->GenerateBuildCommand
+    (makeprogram.c_str(), this->Makefile->GetProjectName(), 0,
+     0, "Release", true);
 
   if(cacheValue)
     {
     return true;
     }
-  m_Makefile->AddCacheDefinition(define,
+  this->Makefile->AddCacheDefinition(define,
                                  makecommand.c_str(),
                                  "Command used to build entire project "
                                  "from the command line.",
diff --git a/Source/cmBuildNameCommand.cxx b/Source/cmBuildNameCommand.cxx
index 06b6658..362c88f 100644
--- a/Source/cmBuildNameCommand.cxx
+++ b/Source/cmBuildNameCommand.cxx
@@ -26,7 +26,7 @@ bool cmBuildNameCommand::InitialPass(std::vector<std::string> const& args)
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  const char* cacheValue = m_Makefile->GetDefinition(args[0].c_str());
+  const char* cacheValue = this->Makefile->GetDefinition(args[0].c_str());
   if(cacheValue)
     {
     // do we need to correct the value? 
@@ -37,7 +37,7 @@ bool cmBuildNameCommand::InitialPass(std::vector<std::string> const& args)
       cmSystemTools::ReplaceString(cv,"/", "_");
       cmSystemTools::ReplaceString(cv,"(", "_");
       cmSystemTools::ReplaceString(cv,")", "_");
-      m_Makefile->AddCacheDefinition(args[0].c_str(),
+      this->Makefile->AddCacheDefinition(args[0].c_str(),
                                      cv.c_str(),
                                      "Name of build.",
                                      cmCacheManager::STRING);
@@ -47,7 +47,7 @@ bool cmBuildNameCommand::InitialPass(std::vector<std::string> const& args)
 
   
   std::string buildname = "WinNT";
-  if(m_Makefile->GetDefinition("UNIX"))
+  if(this->Makefile->GetDefinition("UNIX"))
     {
     buildname = "";
     cmSystemTools::RunSingleCommand("uname -a", &buildname);
@@ -62,7 +62,7 @@ bool cmBuildNameCommand::InitialPass(std::vector<std::string> const& args)
       }
     }
   std::string compiler = "${CMAKE_CXX_COMPILER}";
-  m_Makefile->ExpandVariablesInString ( compiler );
+  this->Makefile->ExpandVariablesInString ( compiler );
   buildname += "-";
   buildname += cmSystemTools::GetFilenameName(compiler);
   cmSystemTools::ReplaceString(buildname,
@@ -72,7 +72,7 @@ bool cmBuildNameCommand::InitialPass(std::vector<std::string> const& args)
   cmSystemTools::ReplaceString(buildname,
                                ")", "_");
   
-  m_Makefile->AddCacheDefinition(args[0].c_str(),
+  this->Makefile->AddCacheDefinition(args[0].c_str(),
                                  buildname.c_str(),
                                  "Name of build.",
                                  cmCacheManager::STRING);
diff --git a/Source/cmCMakeMinimumRequired.cxx b/Source/cmCMakeMinimumRequired.cxx
index b4f4ead..3ee7c27 100644
--- a/Source/cmCMakeMinimumRequired.cxx
+++ b/Source/cmCMakeMinimumRequired.cxx
@@ -67,13 +67,14 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args)
     }
 
   // Save the required version string.
-  m_Makefile->AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION",
-    version_string.c_str());
+  this->Makefile->AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION",
+                                version_string.c_str());
+
 
   // Get the current version number.
-  int current_major = m_Makefile->GetMajorVersion();
-  int current_minor = m_Makefile->GetMinorVersion();
-  int current_patch = m_Makefile->GetPatchVersion();
+  int current_major = this->Makefile->GetMajorVersion();
+  int current_minor = this->Makefile->GetMinorVersion();
+  int current_patch = this->Makefile->GetPatchVersion();
 
   // Parse the required version number.  If no patch-level is given
   // use zero.
diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx
index a302add..a184ece 100644
--- a/Source/cmCPluginAPI.cxx
+++ b/Source/cmCPluginAPI.cxx
@@ -424,12 +424,12 @@ int CCONV cmExecuteCommand(void *arg, const char *name,
 {
   cmMakefile *mf = static_cast<cmMakefile *>(arg);
   cmListFileFunction lff;
-  lff.m_Name = name;
+  lff.Name = name;
   for(int i = 0; i < numArgs; ++i)
     {
     // Assume all arguments are quoted.
-    lff.m_Arguments.push_back(cmListFileArgument(args[i], true,
-                                                 "[CMake-Plugin]", 0));
+    lff.Arguments.push_back(cmListFileArgument(args[i], true,
+                                               "[CMake-Plugin]", 0));
     }
   return mf->ExecuteCommand(lff);
 }
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index 27433bb..3822947 100644
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@@ -124,7 +124,7 @@ std::string cmCTest::CurrentTime()
   struct tm* t = localtime(&currenttime);
   //return ::CleanString(ctime(&currenttime));
   char current_time[1024];
-  if ( m_ShortDateFormat )
+  if ( this->ShortDateFormat )
     {
     strftime(current_time, 1000, "%b %d %H:%M %Z", t);
     }
@@ -218,46 +218,46 @@ std::string cmCTest::MakeURLSafe(const std::string& str)
 //----------------------------------------------------------------------
 cmCTest::cmCTest()
 {
-  m_SubmitIndex            = 0;
-  m_ForceNewCTestProcess   = false;
-  m_TomorrowTag            = false;
-  m_Verbose                = false;
-  m_Debug                  = false;
-  m_ShowLineNumbers        = false;
-  m_Quiet                  = false;
-  m_ExtraVerbose           = false;
-  m_ProduceXML             = false;
-  m_ShowOnly               = false;
-  m_RunConfigurationScript = false;
-  m_TestModel              = cmCTest::EXPERIMENTAL;
-  m_InteractiveDebugMode   = true;
-  m_TimeOut                = 0;
-  m_CompressXMLFiles       = false;
-  m_CTestConfigFile        = "";
-  m_OutputLogFile          = 0;
-  m_OutputLogFileLastTag   = -1;
-  m_SuppressUpdatingCTestConfiguration = false;
-  m_DartVersion            = 1;
+  this->SubmitIndex            = 0;
+  this->ForceNewCTestProcess   = false;
+  this->TomorrowTag            = false;
+  this->Verbose                = false;
+  this->Debug                  = false;
+  this->ShowLineNumbers        = false;
+  this->Quiet                  = false;
+  this->ExtraVerbose           = false;
+  this->ProduceXML             = false;
+  this->ShowOnly               = false;
+  this->RunConfigurationScript = false;
+  this->TestModel              = cmCTest::EXPERIMENTAL;
+  this->InteractiveDebugMode   = true;
+  this->TimeOut                = 0;
+  this->CompressXMLFiles       = false;
+  this->CTestConfigFile        = "";
+  this->OutputLogFile          = 0;
+  this->OutputLogFileLastTag   = -1;
+  this->SuppressUpdatingCTestConfiguration = false;
+  this->DartVersion            = 1;
 
   int cc;
   for ( cc=0; cc < cmCTest::LAST_TEST; cc ++ )
     {
-    m_Tests[cc] = 0;
+    this->Tests[cc] = 0;
     }
-  m_ShortDateFormat        = true;
+  this->ShortDateFormat        = true;
 
-  m_TestingHandlers["build"]     = new cmCTestBuildHandler;
-  m_TestingHandlers["buildtest"] = new cmCTestBuildAndTestHandler;
-  m_TestingHandlers["coverage"]  = new cmCTestCoverageHandler;
-  m_TestingHandlers["script"]    = new cmCTestScriptHandler;
-  m_TestingHandlers["test"]      = new cmCTestTestHandler;
-  m_TestingHandlers["update"]    = new cmCTestUpdateHandler;
-  m_TestingHandlers["configure"] = new cmCTestConfigureHandler;
-  m_TestingHandlers["memcheck"]  = new cmCTestMemCheckHandler;
-  m_TestingHandlers["submit"]    = new cmCTestSubmitHandler;
+  this->TestingHandlers["build"]     = new cmCTestBuildHandler;
+  this->TestingHandlers["buildtest"] = new cmCTestBuildAndTestHandler;
+  this->TestingHandlers["coverage"]  = new cmCTestCoverageHandler;
+  this->TestingHandlers["script"]    = new cmCTestScriptHandler;
+  this->TestingHandlers["test"]      = new cmCTestTestHandler;
+  this->TestingHandlers["update"]    = new cmCTestUpdateHandler;
+  this->TestingHandlers["configure"] = new cmCTestConfigureHandler;
+  this->TestingHandlers["memcheck"]  = new cmCTestMemCheckHandler;
+  this->TestingHandlers["submit"]    = new cmCTestSubmitHandler;
 
   cmCTest::t_TestingHandlers::iterator it;
-  for ( it = m_TestingHandlers.begin(); it != m_TestingHandlers.end(); ++ it )
+  for ( it = this->TestingHandlers.begin(); it != this->TestingHandlers.end(); ++ it )
     {
     it->second->SetCTestInstance(this);
     }
@@ -270,7 +270,7 @@ cmCTest::cmCTest()
 cmCTest::~cmCTest()
 {
   cmCTest::t_TestingHandlers::iterator it;
-  for ( it = m_TestingHandlers.begin(); it != m_TestingHandlers.end(); ++ it )
+  for ( it = this->TestingHandlers.begin(); it != this->TestingHandlers.end(); ++ it )
     {
     delete it->second;
     it->second = 0;
@@ -283,18 +283,18 @@ int cmCTest::Initialize(const char* binary_dir, bool new_tag,
   bool verbose_tag)
 {
   cmCTestLog(this, DEBUG, "Here: " << __LINE__ << std::endl);
-  if(!m_InteractiveDebugMode)
+  if(!this->InteractiveDebugMode)
     {
     this->BlockTestErrorDiagnostics();
     }
 
-  m_BinaryDir = binary_dir;
-  cmSystemTools::ConvertToUnixSlashes(m_BinaryDir);
+  this->BinaryDir = binary_dir;
+  cmSystemTools::ConvertToUnixSlashes(this->BinaryDir);
 
   this->UpdateCTestConfiguration();
 
   cmCTestLog(this, DEBUG, "Here: " << __LINE__ << std::endl);
-  if ( m_ProduceXML )
+  if ( this->ProduceXML )
     {
   cmCTestLog(this, DEBUG, "Here: " << __LINE__ << std::endl);
     cmCTestLog(this, OUTPUT,
@@ -310,16 +310,16 @@ int cmCTest::Initialize(const char* binary_dir, bool new_tag,
       }
     }
 
-  if ( !this->ReadCustomConfigurationFileTree(m_BinaryDir.c_str()) )
+  if ( !this->ReadCustomConfigurationFileTree(this->BinaryDir.c_str()) )
     {
     cmCTestLog(this, DEBUG, "Cannot find custom configuration file tree"
       << std::endl);
     return 0;
     }
 
-  if ( m_ProduceXML )
+  if ( this->ProduceXML )
     {
-    std::string testingDir = m_BinaryDir + "/Testing";
+    std::string testingDir = this->BinaryDir + "/Testing";
     if ( cmSystemTools::FileExists(testingDir.c_str()) )
       {
       if ( !cmSystemTools::FileIsDirectory(testingDir.c_str()) )
@@ -342,7 +342,7 @@ int cmCTest::Initialize(const char* binary_dir, bool new_tag,
     std::ifstream tfin(tagfile.c_str());
     std::string tag;
     time_t tctime = time(0);
-    if ( m_TomorrowTag )
+    if ( this->TomorrowTag )
       {
       tctime += ( 24 * 60 * 60 );
       }
@@ -365,24 +365,24 @@ int cmCTest::Initialize(const char* binary_dir, bool new_tag,
       std::string tagmode;
       if ( cmSystemTools::GetLineFromStream(tfin, tagmode) )
         {
-        if ( tagmode.size() > 4 && !( m_Tests[cmCTest::START_TEST] ||
-            m_Tests[ALL_TEST] ))
+        if ( tagmode.size() > 4 && !( this->Tests[cmCTest::START_TEST] ||
+            this->Tests[ALL_TEST] ))
           {
-          m_TestModel = cmCTest::GetTestModelFromString(tagmode.c_str());
+          this->TestModel = cmCTest::GetTestModelFromString(tagmode.c_str());
           }
         }
       tfin.close();
       }
-    if ( tag.size() == 0 || new_tag || m_Tests[cmCTest::START_TEST] ||
-      m_Tests[ALL_TEST])
+    if ( tag.size() == 0 || new_tag || this->Tests[cmCTest::START_TEST] ||
+      this->Tests[ALL_TEST])
       {
       cmCTestLog(this, DEBUG, "TestModel: " << this->GetTestModelString()
         << std::endl);
-      cmCTestLog(this, DEBUG, "TestModel: " << m_TestModel << std::endl);
-      if ( m_TestModel == cmCTest::NIGHTLY )
+      cmCTestLog(this, DEBUG, "TestModel: " << this->TestModel << std::endl);
+      if ( this->TestModel == cmCTest::NIGHTLY )
         {
         lctime = this->GetNightlyTime(
-          this->GetCTestConfiguration("NightlyStartTime"), m_TomorrowTag);
+          this->GetCTestConfiguration("NightlyStartTime"), this->TomorrowTag);
         }
       char datestring[100];
       sprintf(datestring, "%04d%02d%02d-%02d%02d",
@@ -405,7 +405,7 @@ int cmCTest::Initialize(const char* binary_dir, bool new_tag,
           << this->GetTestModelString() << std::endl);
         }
       }
-    m_CurrentTag = tag;
+    this->CurrentTag = tag;
     }
   return 1;
 }
@@ -413,7 +413,7 @@ int cmCTest::Initialize(const char* binary_dir, bool new_tag,
 //----------------------------------------------------------------------
 bool cmCTest::InitializeFromCommand(cmCTestCommand* command, bool first)
 {
-  if ( !first && !m_CurrentTag.empty() )
+  if ( !first && !this->CurrentTag.empty() )
     {
     return true;
     }
@@ -421,8 +421,8 @@ bool cmCTest::InitializeFromCommand(cmCTestCommand* command, bool first)
   std::string src_dir
     = this->GetCTestConfiguration("SourceDirectory").c_str();
   std::string bld_dir = this->GetCTestConfiguration("BuildDirectory").c_str();
-  m_DartVersion = 1;
-  m_SubmitFiles.clear();
+  this->DartVersion = 1;
+  this->SubmitFiles.clear();
 
   cmMakefile* mf = command->GetMakefile();
   std::string fname = src_dir;
@@ -462,8 +462,8 @@ bool cmCTest::InitializeFromCommand(cmCTestCommand* command, bool first)
   const char* dartVersion = mf->GetDefinition("CTEST_DART_SERVER_VERSION");
   if ( dartVersion )
     {
-    m_DartVersion = atoi(dartVersion);
-    if ( m_DartVersion < 0 )
+    this->DartVersion = atoi(dartVersion);
+    if ( this->DartVersion < 0 )
       {
       cmCTestLog(this, ERROR_MESSAGE, "Invalid Dart server version: "
         << dartVersion << ". Please specify the version number."
@@ -489,23 +489,23 @@ bool cmCTest::InitializeFromCommand(cmCTestCommand* command, bool first)
 //----------------------------------------------------------------------
 bool cmCTest::UpdateCTestConfiguration()
 {
-  if ( m_SuppressUpdatingCTestConfiguration )
+  if ( this->SuppressUpdatingCTestConfiguration )
     {
     return true;
     }
-  std::string fileName = m_CTestConfigFile;
+  std::string fileName = this->CTestConfigFile;
   if ( fileName.empty() )
     {
-    fileName = m_BinaryDir + "/DartConfiguration.tcl";
+    fileName = this->BinaryDir + "/DartConfiguration.tcl";
     if ( !cmSystemTools::FileExists(fileName.c_str()) )
       {
-      fileName = m_BinaryDir + "/CTestConfiguration.ini";
+      fileName = this->BinaryDir + "/CTestConfiguration.ini";
       }
     }
   if ( !cmSystemTools::FileExists(fileName.c_str()) )
     {
     // No need to exit if we are not producing XML
-    if ( m_ProduceXML )
+    if ( this->ProduceXML )
       {
       cmCTestLog(this, ERROR_MESSAGE, "Cannot find file: " << fileName.c_str()
         << std::endl);
@@ -552,14 +552,14 @@ bool cmCTest::UpdateCTestConfiguration()
       std::string key = line.substr(0, cpos);
       std::string value
         = cmCTest::CleanString(line.substr(cpos+1, line.npos));
-      m_CTestConfiguration[key] = value;
+      this->CTestConfiguration[key] = value;
       }
     fin.close();
     }
-  m_TimeOut = atoi(this->GetCTestConfiguration("TimeOut").c_str());
-  if ( m_ProduceXML )
+  this->TimeOut = atoi(this->GetCTestConfiguration("TimeOut").c_str());
+  if ( this->ProduceXML )
     {
-    m_CompressXMLFiles = cmSystemTools::IsOn(
+    this->CompressXMLFiles = cmSystemTools::IsOn(
       this->GetCTestConfiguration("CompressSubmission").c_str());
     }
   return true;
@@ -578,8 +578,8 @@ void cmCTest::BlockTestErrorDiagnostics()
 //----------------------------------------------------------------------
 void cmCTest::SetTestModel(int mode)
 {
-  m_InteractiveDebugMode = false;
-  m_TestModel = mode;
+  this->InteractiveDebugMode = false;
+  this->TestModel = mode;
 }
 
 //----------------------------------------------------------------------
@@ -587,43 +587,43 @@ bool cmCTest::SetTest(const char* ttype, bool report)
 {
   if ( cmSystemTools::LowerCase(ttype) == "all" )
     {
-    m_Tests[cmCTest::ALL_TEST] = 1;
+    this->Tests[cmCTest::ALL_TEST] = 1;
     }
   else if ( cmSystemTools::LowerCase(ttype) == "start" )
     {
-    m_Tests[cmCTest::START_TEST] = 1;
+    this->Tests[cmCTest::START_TEST] = 1;
     }
   else if ( cmSystemTools::LowerCase(ttype) == "update" )
     {
-    m_Tests[cmCTest::UPDATE_TEST] = 1;
+    this->Tests[cmCTest::UPDATE_TEST] = 1;
     }
   else if ( cmSystemTools::LowerCase(ttype) == "configure" )
     {
-    m_Tests[cmCTest::CONFIGURE_TEST] = 1;
+    this->Tests[cmCTest::CONFIGURE_TEST] = 1;
     }
   else if ( cmSystemTools::LowerCase(ttype) == "build" )
     {
-    m_Tests[cmCTest::BUILD_TEST] = 1;
+    this->Tests[cmCTest::BUILD_TEST] = 1;
     }
   else if ( cmSystemTools::LowerCase(ttype) == "test" )
     {
-    m_Tests[cmCTest::TEST_TEST] = 1;
+    this->Tests[cmCTest::TEST_TEST] = 1;
     }
   else if ( cmSystemTools::LowerCase(ttype) == "coverage" )
     {
-    m_Tests[cmCTest::COVERAGE_TEST] = 1;
+    this->Tests[cmCTest::COVERAGE_TEST] = 1;
     }
   else if ( cmSystemTools::LowerCase(ttype) == "memcheck" )
     {
-    m_Tests[cmCTest::MEMCHECK_TEST] = 1;
+    this->Tests[cmCTest::MEMCHECK_TEST] = 1;
     }
   else if ( cmSystemTools::LowerCase(ttype) == "notes" )
     {
-    m_Tests[cmCTest::NOTES_TEST] = 1;
+    this->Tests[cmCTest::NOTES_TEST] = 1;
     }
   else if ( cmSystemTools::LowerCase(ttype) == "submit" )
     {
-    m_Tests[cmCTest::SUBMIT_TEST] = 1;
+    this->Tests[cmCTest::SUBMIT_TEST] = 1;
     }
   else
     {
@@ -647,7 +647,7 @@ bool cmCTest::OpenOutputFile(const std::string& path,
                      const std::string& name, cmGeneratedFileStream& stream,
                      bool compress)
 {
-  std::string testingDir = m_BinaryDir + "/Testing";
+  std::string testingDir = this->BinaryDir + "/Testing";
   if ( path.size() > 0 )
     {
     testingDir += "/" + path;
@@ -681,7 +681,7 @@ bool cmCTest::OpenOutputFile(const std::string& path,
     }
   if ( compress )
     {
-    if ( m_CompressXMLFiles )
+    if ( this->CompressXMLFiles )
       {
       stream.SetCompression(true);
       }
@@ -715,7 +715,7 @@ bool cmCTest::AddIfExists(SetOfStrings& files, const char* file)
 //----------------------------------------------------------------------
 bool cmCTest::CTestFileExists(const std::string& filename)
 {
-  std::string testingDir = m_BinaryDir + "/Testing/" + m_CurrentTag + "/" +
+  std::string testingDir = this->BinaryDir + "/Testing/" + this->CurrentTag + "/" +
     filename;
   return cmSystemTools::FileExists(testingDir.c_str());
 }
@@ -723,8 +723,8 @@ bool cmCTest::CTestFileExists(const std::string& filename)
 //----------------------------------------------------------------------
 cmCTestGenericHandler* cmCTest::GetInitializedHandler(const char* handler)
 {
-  cmCTest::t_TestingHandlers::iterator it = m_TestingHandlers.find(handler);
-  if ( it == m_TestingHandlers.end() )
+  cmCTest::t_TestingHandlers::iterator it = this->TestingHandlers.find(handler);
+  if ( it == this->TestingHandlers.end() )
     {
     return 0;
     }
@@ -735,8 +735,8 @@ cmCTestGenericHandler* cmCTest::GetInitializedHandler(const char* handler)
 //----------------------------------------------------------------------
 cmCTestGenericHandler* cmCTest::GetHandler(const char* handler)
 {
-  cmCTest::t_TestingHandlers::iterator it = m_TestingHandlers.find(handler);
-  if ( it == m_TestingHandlers.end() )
+  cmCTest::t_TestingHandlers::iterator it = this->TestingHandlers.find(handler);
+  if ( it == this->TestingHandlers.end() )
     {
     return 0;
     }
@@ -767,13 +767,13 @@ int cmCTest::ProcessTests()
 
   for ( cc = 0; cc < LAST_TEST; cc ++ )
     {
-    if ( m_Tests[cc] )
+    if ( this->Tests[cc] )
       {
       notest = false;
       break;
       }
     }
-  if ( m_Tests[UPDATE_TEST] || m_Tests[ALL_TEST] )
+  if ( this->Tests[UPDATE_TEST] || this->Tests[ALL_TEST] )
     {
     cmCTestGenericHandler* uphandler = this->GetHandler("update");
     uphandler->SetOption("SourceDirectory",
@@ -784,18 +784,18 @@ int cmCTest::ProcessTests()
       res |= cmCTest::UPDATE_ERRORS;
       }
     }
-  if ( m_TestModel == cmCTest::CONTINUOUS && !update_count )
+  if ( this->TestModel == cmCTest::CONTINUOUS && !update_count )
     {
     return 0;
     }
-  if ( m_Tests[CONFIGURE_TEST] || m_Tests[ALL_TEST] )
+  if ( this->Tests[CONFIGURE_TEST] || this->Tests[ALL_TEST] )
     {
     if (this->GetHandler("configure")->ProcessHandler() < 0)
       {
       res |= cmCTest::CONFIGURE_ERRORS;
       }
     }
-  if ( m_Tests[BUILD_TEST] || m_Tests[ALL_TEST] )
+  if ( this->Tests[BUILD_TEST] || this->Tests[ALL_TEST] )
     {
     this->UpdateCTestConfiguration();
     if (this->GetHandler("build")->ProcessHandler() < 0)
@@ -803,7 +803,7 @@ int cmCTest::ProcessTests()
       res |= cmCTest::BUILD_ERRORS;
       }
     }
-  if ( m_Tests[TEST_TEST] || m_Tests[ALL_TEST] || notest )
+  if ( this->Tests[TEST_TEST] || this->Tests[ALL_TEST] || notest )
     {
     this->UpdateCTestConfiguration();
     if (this->GetHandler("test")->ProcessHandler() < 0)
@@ -811,7 +811,7 @@ int cmCTest::ProcessTests()
       res |= cmCTest::TEST_ERRORS;
       }
     }
-  if ( m_Tests[COVERAGE_TEST] || m_Tests[ALL_TEST] )
+  if ( this->Tests[COVERAGE_TEST] || this->Tests[ALL_TEST] )
     {
     this->UpdateCTestConfiguration();
     if (this->GetHandler("coverage")->ProcessHandler() < 0)
@@ -819,7 +819,7 @@ int cmCTest::ProcessTests()
       res |= cmCTest::COVERAGE_ERRORS;
       }
     }
-  if ( m_Tests[MEMCHECK_TEST] || m_Tests[ALL_TEST] )
+  if ( this->Tests[MEMCHECK_TEST] || this->Tests[ALL_TEST] )
     {
     this->UpdateCTestConfiguration();
     if (this->GetHandler("memcheck")->ProcessHandler() < 0)
@@ -829,7 +829,7 @@ int cmCTest::ProcessTests()
     }
   if ( !notest )
     {
-    std::string notes_dir = m_BinaryDir + "/Testing/Notes";
+    std::string notes_dir = this->BinaryDir + "/Testing/Notes";
     if ( cmSystemTools::FileIsDirectory(notes_dir.c_str()) )
       {
       cmsys::Directory d;
@@ -842,25 +842,25 @@ int cmCTest::ProcessTests()
         if ( cmSystemTools::FileExists(fullname.c_str()) &&
           !cmSystemTools::FileIsDirectory(fullname.c_str()) )
           {
-          if ( m_NotesFiles.size() > 0 )
+          if ( this->NotesFiles.size() > 0 )
             {
-            m_NotesFiles += ";";
+            this->NotesFiles += ";";
             }
-          m_NotesFiles += fullname;
-          m_Tests[NOTES_TEST] = 1;
+          this->NotesFiles += fullname;
+          this->Tests[NOTES_TEST] = 1;
           }
         }
       }
     }
-  if ( m_Tests[NOTES_TEST] || m_Tests[ALL_TEST] )
+  if ( this->Tests[NOTES_TEST] || this->Tests[ALL_TEST] )
     {
     this->UpdateCTestConfiguration();
-    if ( m_NotesFiles.size() )
+    if ( this->NotesFiles.size() )
       {
-      this->GenerateNotesFile(m_NotesFiles.c_str());
+      this->GenerateNotesFile(this->NotesFiles.c_str());
       }
     }
-  if ( m_Tests[SUBMIT_TEST] || m_Tests[ALL_TEST] )
+  if ( this->Tests[SUBMIT_TEST] || this->Tests[ALL_TEST] )
     {
     this->UpdateCTestConfiguration();
     if (this->GetHandler("submit")->ProcessHandler() < 0)
@@ -879,7 +879,7 @@ int cmCTest::ProcessTests()
 //----------------------------------------------------------------------
 std::string cmCTest::GetTestModelString()
 {
-  switch ( m_TestModel )
+  switch ( this->TestModel )
     {
   case cmCTest::NIGHTLY:
     return "Nightly";
@@ -1041,12 +1041,12 @@ int cmCTest::RunTest(std::vector<const char*> argv,
                      std::string* output, int *retVal,
                      std::ostream* log)
 {
-  if(cmSystemTools::SameFile(argv[0], m_CTestSelf.c_str()) &&
-     !m_ForceNewCTestProcess)
+  if(cmSystemTools::SameFile(argv[0], this->CTestSelf.c_str()) &&
+     !this->ForceNewCTestProcess)
     {
     cmCTest inst;
-    inst.m_ConfigType = m_ConfigType;
-    inst.m_TimeOut = m_TimeOut;
+    inst.ConfigType = this->ConfigType;
+    inst.TimeOut = this->TimeOut;
     std::vector<std::string> args;
     for(unsigned int i =0; i < argv.size(); ++i)
       {
@@ -1086,7 +1086,7 @@ int cmCTest::RunTest(std::vector<const char*> argv,
     {
     cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
     }
-  cmsysProcess_SetTimeout(cp, m_TimeOut);
+  cmsysProcess_SetTimeout(cp, this->TimeOut);
   cmsysProcess_Execute(cp);
 
   char* data;
@@ -1145,7 +1145,7 @@ void cmCTest::StartXML(std::ostream& ostr)
 {
   ostr << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
     << "<Site BuildName=\"" << this->GetCTestConfiguration("BuildName")
-    << "\" BuildStamp=\"" << m_CurrentTag << "-"
+    << "\" BuildStamp=\"" << this->CurrentTag << "-"
     << this->GetTestModelString() << "\" Name=\""
     << this->GetCTestConfiguration("Site") << "\" Generator=\"ctest"
     << cmVersion::GetCMakeVersion()
@@ -1169,7 +1169,7 @@ int cmCTest::GenerateCTestNotesOutput(std::ostream& os,
     "<file:///Dart/Source/Server/XSL/Build.xsl> \"?>\n"
     << "<Site BuildName=\"" << this->GetCTestConfiguration("BuildName")
     << "\" BuildStamp=\""
-    << m_CurrentTag << "-" << this->GetTestModelString() << "\" Name=\""
+    << this->CurrentTag << "-" << this->GetTestModelString() << "\" Name=\""
     << this->GetCTestConfiguration("Site") << "\" Generator=\"ctest"
     << cmVersion::GetCMakeVersion()
     << "\">\n"
@@ -1210,7 +1210,7 @@ int cmCTest::GenerateCTestNotesOutput(std::ostream& os,
 int cmCTest::GenerateNotesFile(const std::vector<cmStdString> &files)
 {
   cmGeneratedFileStream ofs;
-  if ( !this->OpenOutputFile(m_CurrentTag, "Notes.xml", ofs) )
+  if ( !this->OpenOutputFile(this->CurrentTag, "Notes.xml", ofs) )
     {
     cmCTestLog(this, ERROR_MESSAGE, "Cannot open notes file" << std::endl);
     return 1;
@@ -1306,47 +1306,47 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
     if(this->CheckArgument(arg, "--ctest-config") && i < args.size() - 1)
       {
       i++;
-      this->m_CTestConfigFile= args[i];
+      this->CTestConfigFile= args[i];
       }
 
     if(this->CheckArgument(arg, "-C", "--build-config") &&
       i < args.size() - 1)
       {
       i++;
-      this->m_ConfigType = args[i];
-      cmSystemTools::ReplaceString(this->m_ConfigType, ".\\", "");
+      this->ConfigType = args[i];
+      cmSystemTools::ReplaceString(this->ConfigType, ".\\", "");
       }
 
     if(this->CheckArgument(arg, "--debug"))
       {
-      this->m_Debug = true;
+      this->Debug = true;
       }
     if(this->CheckArgument(arg, "--show-line-numbers"))
       {
-      this->m_ShowLineNumbers = true;
+      this->ShowLineNumbers = true;
       }
     if(this->CheckArgument(arg, "-Q", "--quiet"))
       {
-      this->m_Quiet = true;
+      this->Quiet = true;
       }
     if(this->CheckArgument(arg, "-V", "--verbose"))
       {
-      this->m_Verbose = true;
+      this->Verbose = true;
       }
     if(this->CheckArgument(arg, "-VV", "--extra-verbose"))
       {
-      this->m_ExtraVerbose = true;
-      this->m_Verbose = true;
+      this->ExtraVerbose = true;
+      this->Verbose = true;
       }
 
     if(this->CheckArgument(arg, "-N", "--show-only"))
       {
-      this->m_ShowOnly = true;
+      this->ShowOnly = true;
       }
 
     if(this->CheckArgument(arg, "-S", "--script") && i < args.size() - 1 )
       {
-      this->m_RunConfigurationScript = true;
+      this->RunConfigurationScript = true;
       i++;
       cmCTestScriptHandler* ch
         = static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
@@ -1361,30 +1361,30 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
 
     if(this->CheckArgument(arg, "--tomorrow-tag"))
       {
-      m_TomorrowTag = true;
+      this->TomorrowTag = true;
       }
     if(this->CheckArgument(arg, "--force-new-ctest-process"))
       {
-      m_ForceNewCTestProcess = true;
+      this->ForceNewCTestProcess = true;
       }
     if(this->CheckArgument(arg, "--interactive-debug-mode") &&
       i < args.size() - 1 )
       {
       i++;
-      m_InteractiveDebugMode = cmSystemTools::IsOn(args[i].c_str());
+      this->InteractiveDebugMode = cmSystemTools::IsOn(args[i].c_str());
       }
     if(this->CheckArgument(arg, "--submit-index") && i < args.size() - 1 )
       {
       i++;
-      m_SubmitIndex = atoi(args[i].c_str());
-      if ( m_SubmitIndex < 0 )
+      this->SubmitIndex = atoi(args[i].c_str());
+      if ( this->SubmitIndex < 0 )
         {
-        m_SubmitIndex = 0;
+        this->SubmitIndex = 0;
         }
       }
     if(this->CheckArgument(arg, "-D", "--dashboard") && i < args.size() - 1 )
       {
-      this->m_ProduceXML = true;
+      this->ProduceXML = true;
       i++;
       std::string targ = args[i];
       if ( targ == "Experimental" )
@@ -1591,7 +1591,7 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
     if(this->CheckArgument(arg, "-T", "--test-action") &&
       (i < args.size() -1) )
       {
-      this->m_ProduceXML = true;
+      this->ProduceXML = true;
       i++;
       if ( !this->SetTest(args[i].c_str(), false) )
         {
@@ -1676,14 +1676,14 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
       }
     if(this->CheckArgument(arg, "-A", "--add-notes") && i < args.size() - 1)
       {
-      this->m_ProduceXML = true;
+      this->ProduceXML = true;
       this->SetTest("Notes");
       i++;
       this->SetNotesFiles(args[i].c_str());
       }
     if(this->CheckArgument(arg, "--extra-submit") && i < args.size() - 1)
       {
-      this->m_ProduceXML = true;
+      this->ProduceXML = true;
       this->SetTest("Submit");
       i++;
       if ( !this->SubmitExtraFiles(args[i].c_str()) )
@@ -1697,8 +1697,8 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
       cmakeAndTest = true;
       }
     cmCTest::t_TestingHandlers::iterator it;
-    for ( it = m_TestingHandlers.begin();
-      it != m_TestingHandlers.end();
+    for ( it = this->TestingHandlers.begin();
+      it != this->TestingHandlers.end();
       ++ it )
       {
       if ( !it->second->ProcessCommandLineArguments(arg, i, args) )
@@ -1711,16 +1711,16 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
     }
 
   // default to the build type of ctest itself
-  if(m_ConfigType.size() == 0)
+  if(this->ConfigType.size() == 0)
     {
 #ifdef  CMAKE_INTDIR
-    m_ConfigType = CMAKE_INTDIR;
+    this->ConfigType = CMAKE_INTDIR;
 #endif
     }
 
   if(cmakeAndTest)
     {
-    m_Verbose = true;
+    this->Verbose = true;
     cmCTestBuildAndTestHandler* handler =
       static_cast<cmCTestBuildAndTestHandler*>(this->GetHandler("buildtest"));
     int retv = handler->ProcessHandler();
@@ -1735,34 +1735,34 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
     {
     int res;
     // call process directory
-    if (this->m_RunConfigurationScript)
+    if (this->RunConfigurationScript)
       {
-      if ( m_ExtraVerbose )
+      if ( this->ExtraVerbose )
         {
         cmCTestLog(this, OUTPUT, "* Extra verbosity turned on" << std::endl);
         }
       cmCTest::t_TestingHandlers::iterator it;
-      for ( it = m_TestingHandlers.begin();
-        it != m_TestingHandlers.end();
+      for ( it = this->TestingHandlers.begin();
+        it != this->TestingHandlers.end();
         ++ it )
         {
-        it->second->SetVerbose(this->m_ExtraVerbose);
-        it->second->SetSubmitIndex(m_SubmitIndex);
+        it->second->SetVerbose(this->ExtraVerbose);
+        it->second->SetSubmitIndex(this->SubmitIndex);
         }
-      this->GetHandler("script")->SetVerbose(m_Verbose);
+      this->GetHandler("script")->SetVerbose(this->Verbose);
       res = this->GetHandler("script")->ProcessHandler();
       }
     else
       {
-      m_ExtraVerbose = m_Verbose;
-      m_Verbose = true;
+      this->ExtraVerbose = this->Verbose;
+      this->Verbose = true;
       cmCTest::t_TestingHandlers::iterator it;
-      for ( it = m_TestingHandlers.begin();
-        it != m_TestingHandlers.end();
+      for ( it = this->TestingHandlers.begin();
+        it != this->TestingHandlers.end();
         ++ it )
         {
-        it->second->SetVerbose(this->m_Verbose);
-        it->second->SetSubmitIndex(m_SubmitIndex);
+        it->second->SetVerbose(this->Verbose);
+        it->second->SetSubmitIndex(this->SubmitIndex);
         }
       cmCTestLog(this, DEBUG, "Here: " << __LINE__ << std::endl);
       if ( !this->Initialize(
@@ -1789,18 +1789,18 @@ void cmCTest::FindRunningCMake(const char* arg0)
 {
   // Find our own executable.
   std::vector<cmStdString> failures;
-  m_CTestSelf = arg0;
-  cmSystemTools::ConvertToUnixSlashes(m_CTestSelf);
-  failures.push_back(m_CTestSelf);
-  m_CTestSelf = cmSystemTools::FindProgram(m_CTestSelf.c_str());
-  if(!cmSystemTools::FileExists(m_CTestSelf.c_str()))
+  this->CTestSelf = arg0;
+  cmSystemTools::ConvertToUnixSlashes(this->CTestSelf);
+  failures.push_back(this->CTestSelf);
+  this->CTestSelf = cmSystemTools::FindProgram(this->CTestSelf.c_str());
+  if(!cmSystemTools::FileExists(this->CTestSelf.c_str()))
     {
-    failures.push_back(m_CTestSelf);
-    m_CTestSelf =  "/usr/local/bin/ctest";
+    failures.push_back(this->CTestSelf);
+    this->CTestSelf =  "/usr/local/bin/ctest";
     }
-  if(!cmSystemTools::FileExists(m_CTestSelf.c_str()))
+  if(!cmSystemTools::FileExists(this->CTestSelf.c_str()))
     {
-    failures.push_back(m_CTestSelf);
+    failures.push_back(this->CTestSelf);
     cmOStringStream msg;
     msg << "CTEST can not find the command line program ctest.\n";
     msg << "  argv[0] = \"" << arg0 << "\"\n";
@@ -1814,31 +1814,31 @@ void cmCTest::FindRunningCMake(const char* arg0)
     }
   std::string dir;
   std::string file;
-  if(cmSystemTools::SplitProgramPath(m_CTestSelf.c_str(),
+  if(cmSystemTools::SplitProgramPath(this->CTestSelf.c_str(),
                                      dir, file, true))
     {
-    m_CMakeSelf = dir += "/cmake";
-    m_CMakeSelf += cmSystemTools::GetExecutableExtension();
-    if(cmSystemTools::FileExists(m_CMakeSelf.c_str()))
+    this->CMakeSelf = dir += "/cmake";
+    this->CMakeSelf += cmSystemTools::GetExecutableExtension();
+    if(cmSystemTools::FileExists(this->CMakeSelf.c_str()))
       {
       return;
       }
     }
-  failures.push_back(m_CMakeSelf);
+  failures.push_back(this->CMakeSelf);
 #ifdef CMAKE_BUILD_DIR
   std::string intdir = ".";
 #ifdef  CMAKE_INTDIR
   intdir = CMAKE_INTDIR;
 #endif
-  m_CMakeSelf = CMAKE_BUILD_DIR;
-  m_CMakeSelf += "/bin/";
-  m_CMakeSelf += intdir;
-  m_CMakeSelf += "/cmake";
-  m_CMakeSelf += cmSystemTools::GetExecutableExtension();
+  this->CMakeSelf = CMAKE_BUILD_DIR;
+  this->CMakeSelf += "/bin/";
+  this->CMakeSelf += intdir;
+  this->CMakeSelf += "/cmake";
+  this->CMakeSelf += cmSystemTools::GetExecutableExtension();
 #endif
-  if(!cmSystemTools::FileExists(m_CMakeSelf.c_str()))
+  if(!cmSystemTools::FileExists(this->CMakeSelf.c_str()))
     {
-    failures.push_back(m_CMakeSelf);
+    failures.push_back(this->CMakeSelf);
     cmOStringStream msg;
     msg << "CTEST can not find the command line program cmake.\n";
     msg << "  argv[0] = \"" << arg0 << "\"\n";
@@ -1859,7 +1859,7 @@ void cmCTest::SetNotesFiles(const char* notes)
     {
     return;
     }
-  m_NotesFiles = notes;
+  this->NotesFiles = notes;
 }
 
 //----------------------------------------------------------------------
@@ -1895,7 +1895,7 @@ int cmCTest::ReadCustomConfigurationFileTree(const char* dir)
     }
 
   cmCTest::t_TestingHandlers::iterator it;
-  for ( it = m_TestingHandlers.begin(); it != m_TestingHandlers.end(); ++ it )
+  for ( it = this->TestingHandlers.begin(); it != this->TestingHandlers.end(); ++ it )
     {
     it->second->PopulateCustomVectors(mf);
     }
@@ -1999,18 +1999,18 @@ std::string cmCTest::GetShortPathToFile(const char* cfname)
 //----------------------------------------------------------------------
 std::string cmCTest::GetCTestConfiguration(const char *name)
 {
-  if ( m_CTestConfigurationOverwrites.find(name) !=
-    m_CTestConfigurationOverwrites.end() )
+  if ( this->CTestConfigurationOverwrites.find(name) !=
+    this->CTestConfigurationOverwrites.end() )
     {
-    return m_CTestConfigurationOverwrites[name];
+    return this->CTestConfigurationOverwrites[name];
     }
-  return m_CTestConfiguration[name];
+  return this->CTestConfiguration[name];
 }
 
 //----------------------------------------------------------------------
 void cmCTest::EmptyCTestConfiguration()
 {
-  m_CTestConfiguration.clear();
+  this->CTestConfiguration.clear();
 }
 
 //----------------------------------------------------------------------
@@ -2022,53 +2022,53 @@ void cmCTest::SetCTestConfiguration(const char *name, const char* value)
     }
   if ( !value )
     {
-    m_CTestConfiguration.erase(name);
+    this->CTestConfiguration.erase(name);
     return;
     }
-  m_CTestConfiguration[name] = value;
+  this->CTestConfiguration[name] = value;
 }
 
 
 //----------------------------------------------------------------------
 std::string cmCTest::GetCurrentTag()
 {
-  return m_CurrentTag;
+  return this->CurrentTag;
 }
 
 //----------------------------------------------------------------------
 std::string cmCTest::GetBinaryDir()
 {
-  return m_BinaryDir;
+  return this->BinaryDir;
 }
 
 //----------------------------------------------------------------------
 std::string cmCTest::GetConfigType()
 {
-  return m_ConfigType;
+  return this->ConfigType;
 }
 
 //----------------------------------------------------------------------
 bool cmCTest::GetShowOnly()
 {
-  return m_ShowOnly;
+  return this->ShowOnly;
 }
 
 //----------------------------------------------------------------------
 void cmCTest::SetProduceXML(bool v)
 {
-  m_ProduceXML = v;
+  this->ProduceXML = v;
 }
 
 //----------------------------------------------------------------------
 bool cmCTest::GetProduceXML()
 {
-  return m_ProduceXML;
+  return this->ProduceXML;
 }
 
 //----------------------------------------------------------------------
 void cmCTest::AddSubmitFile(const char* name)
 {
-  m_SubmitFiles.insert(name);
+  this->SubmitFiles.insert(name);
 }
 
 //----------------------------------------------------------------------
@@ -2087,7 +2087,7 @@ void cmCTest::AddCTestConfigurationOverwrite(const char* encstr)
     }
   std::string key = overStr.substr(0, epos);
   std::string value = overStr.substr(epos+1, overStr.npos);
-  m_CTestConfigurationOverwrites[key] = value;
+  this->CTestConfigurationOverwrites[key] = value;
 }
 
 //----------------------------------------------------------------------
@@ -2161,7 +2161,7 @@ bool cmCTest::RunCommand(
       done = true;
       }
     if ( (res == cmsysProcess_Pipe_STDOUT ||
-        res == cmsysProcess_Pipe_STDERR) && m_ExtraVerbose )
+        res == cmsysProcess_Pipe_STDERR) && this->ExtraVerbose )
       {
       cmSystemTools::Stdout(data, length);
       }
@@ -2215,14 +2215,14 @@ bool cmCTest::RunCommand(
 //----------------------------------------------------------------------
 void cmCTest::SetOutputLogFileName(const char* name)
 {
-  if ( m_OutputLogFile)
+  if ( this->OutputLogFile)
     {
-    delete m_OutputLogFile;
-    m_OutputLogFile= 0;
+    delete this->OutputLogFile;
+    this->OutputLogFile= 0;
     }
   if ( name )
     {
-    m_OutputLogFile = new cmGeneratedFileStream(name);
+    this->OutputLogFile = new cmGeneratedFileStream(name);
     }
 }
 
@@ -2247,7 +2247,7 @@ static const char* cmCTestStringLogType[] =
 #endif
 
 #define cmCTestLogOutputFileLine(stream) \
-  if ( m_ShowLineNumbers ) \
+  if ( this->ShowLineNumbers ) \
     { \
     (stream) << std::endl << file << ":" << line << " "; \
     }
@@ -2258,42 +2258,42 @@ void cmCTest::Log(int logType, const char* file, int line, const char* msg)
     {
     return;
     }
-  if ( m_OutputLogFile )
+  if ( this->OutputLogFile )
     {
     bool display = true;
-    if ( logType == cmCTest::DEBUG && !m_Debug ) { display = false; }
-    if ( logType == cmCTest::HANDLER_VERBOSE_OUTPUT && !m_Debug &&
-      !m_ExtraVerbose ) { display = false; }
+    if ( logType == cmCTest::DEBUG && !this->Debug ) { display = false; }
+    if ( logType == cmCTest::HANDLER_VERBOSE_OUTPUT && !this->Debug &&
+      !this->ExtraVerbose ) { display = false; }
     if ( display )
       {
-      cmCTestLogOutputFileLine(*m_OutputLogFile);
-      if ( logType != m_OutputLogFileLastTag )
+      cmCTestLogOutputFileLine(*this->OutputLogFile);
+      if ( logType != this->OutputLogFileLastTag )
         {
-        *m_OutputLogFile << "[";
+        *this->OutputLogFile << "[";
         if ( logType >= OTHER || logType < 0 )
           {
-          *m_OutputLogFile << "OTHER";
+          *this->OutputLogFile << "OTHER";
           }
         else
           {
-          *m_OutputLogFile << cmCTestStringLogType[logType];
+          *this->OutputLogFile << cmCTestStringLogType[logType];
           }
-        *m_OutputLogFile << "] " << std::endl << std::flush;
+        *this->OutputLogFile << "] " << std::endl << std::flush;
         }
-      *m_OutputLogFile << msg << std::flush;
-      if ( logType != m_OutputLogFileLastTag )
+      *this->OutputLogFile << msg << std::flush;
+      if ( logType != this->OutputLogFileLastTag )
         {
-        *m_OutputLogFile << std::endl << std::flush;
-        m_OutputLogFileLastTag = logType;
+        *this->OutputLogFile << std::endl << std::flush;
+        this->OutputLogFileLastTag = logType;
         }
       }
     }
-  if ( !m_Quiet )
+  if ( !this->Quiet )
     {
     switch ( logType )
       {
     case DEBUG:
-      if ( m_Debug )
+      if ( this->Debug )
         {
         cmCTestLogOutputFileLine(std::cout);
         std::cout << msg;
@@ -2301,7 +2301,7 @@ void cmCTest::Log(int logType, const char* file, int line, const char* msg)
         }
       break;
     case OUTPUT: case HANDLER_OUTPUT:
-      if ( m_Debug || m_Verbose )
+      if ( this->Debug || this->Verbose )
         {
         cmCTestLogOutputFileLine(std::cout);
         std::cout << msg;
@@ -2309,7 +2309,7 @@ void cmCTest::Log(int logType, const char* file, int line, const char* msg)
         }
       break;
     case HANDLER_VERBOSE_OUTPUT:
-      if ( m_Debug || m_ExtraVerbose )
+      if ( this->Debug || this->ExtraVerbose )
         {
         cmCTestLogOutputFileLine(std::cout);
         std::cout << msg;
diff --git a/Source/cmCTest.h b/Source/cmCTest.h
index 622fe84..e8eb1b7 100644
--- a/Source/cmCTest.h
+++ b/Source/cmCTest.h
@@ -84,7 +84,7 @@ public:
   /*
    * Is the tomorrow tag set?
    */
-  bool GetTomorrowTag() { return m_TomorrowTag; };
+  bool GetTomorrowTag() { return this->TomorrowTag; };
 
   /**
    * Try to run tests of the project
@@ -93,8 +93,8 @@ public:
 
   ///! what is the configuraiton type, e.g. Debug, Release etc.
   std::string GetConfigType();
-  double GetTimeOut() { return m_TimeOut; }
-  void SetTimeOut(double t) { m_TimeOut = t; }
+  double GetTimeOut() { return this->TimeOut; }
+  void SetTimeOut(double t) { this->TimeOut = t; }
 
   /**
    * Check if CTest file exists
@@ -111,7 +111,7 @@ public:
    * Set the cmake test mode (experimental, nightly, continuous).
    */
   void SetTestModel(int mode);
-  int GetTestModel() { return m_TestModel; };
+  int GetTestModel() { return this->TestModel; };
 
   std::string GetTestModelString();
   static int GetTestModelFromString(const char* str);
@@ -198,8 +198,8 @@ public:
   std::string GetShortPathToFile(const char* fname);
 
   //! Get the path to CTest
-  const char* GetCTestExecutable() { return m_CTestSelf.c_str(); }
-  const char* GetCMakeExecutable() { return m_CMakeSelf.c_str(); }
+  const char* GetCTestExecutable() { return this->CTestSelf.c_str(); }
+  const char* GetCMakeExecutable() { return this->CMakeSelf.c_str(); }
 
   enum {
     EXPERIMENTAL,
@@ -252,7 +252,7 @@ public:
   // script, this should be true.
   void SetSuppressUpdatingCTestConfiguration(bool val)
     {
-    m_SuppressUpdatingCTestConfiguration = val;
+    this->SuppressUpdatingCTestConfiguration = val;
     }
 
   //! Add overwrite to ctest configuration.
@@ -284,29 +284,29 @@ public:
   void Log(int logType, const char* file, int line, const char* msg);
 
   //! Get the version of dart server
-  int GetDartVersion() { return m_DartVersion; }
+  int GetDartVersion() { return this->DartVersion; }
 
   //! Add file to be submitted
   void AddSubmitFile(const char* name);
-  SetOfStrings* GetSubmitFiles() { return &m_SubmitFiles; }
+  SetOfStrings* GetSubmitFiles() { return &this->SubmitFiles; }
 
 private:
-  std::string m_ConfigType;
-  bool m_Verbose;
-  bool m_ExtraVerbose;
-  bool m_ProduceXML;
+  std::string ConfigType;
+  bool Verbose;
+  bool ExtraVerbose;
+  bool ProduceXML;
 
-  bool m_ForceNewCTestProcess;
+  bool ForceNewCTestProcess;
 
-  bool m_RunConfigurationScript;
+  bool RunConfigurationScript;
 
   int GenerateNotesFile(const char* files);
 
   // these are helper classes
   typedef std::map<cmStdString,cmCTestGenericHandler*> t_TestingHandlers;
-  t_TestingHandlers m_TestingHandlers;
+  t_TestingHandlers TestingHandlers;
 
-  bool m_ShowOnly;
+  bool ShowOnly;
 
   enum {
     FIRST_TEST     = 0,
@@ -326,35 +326,35 @@ private:
   //! Map of configuration properties
   typedef std::map<cmStdString, cmStdString> CTestConfigurationMap;
 
-  std::string             m_CTestConfigFile;
-  CTestConfigurationMap m_CTestConfiguration;
-  CTestConfigurationMap m_CTestConfigurationOverwrites;
-  int                     m_Tests[LAST_TEST];
+  std::string             CTestConfigFile;
+  CTestConfigurationMap CTestConfiguration;
+  CTestConfigurationMap CTestConfigurationOverwrites;
+  int                     Tests[LAST_TEST];
 
-  std::string             m_CurrentTag;
-  bool                    m_TomorrowTag;
+  std::string             CurrentTag;
+  bool                    TomorrowTag;
 
-  int                     m_TestModel;
+  int                     TestModel;
 
-  double                  m_TimeOut;
+  double                  TimeOut;
 
-  int                     m_CompatibilityMode;
+  int                     CompatibilityMode;
 
   // information for the --build-and-test options
-  std::string              m_CMakeSelf;
-  std::string              m_CTestSelf;
-  std::string              m_BinaryDir;
+  std::string              CMakeSelf;
+  std::string              CTestSelf;
+  std::string              BinaryDir;
 
-  std::string              m_NotesFiles;
+  std::string              NotesFiles;
 
 
   int ReadCustomConfigurationFileTree(const char* dir);
 
-  bool                     m_InteractiveDebugMode;
+  bool                     InteractiveDebugMode;
 
-  bool                     m_ShortDateFormat;
+  bool                     ShortDateFormat;
 
-  bool                     m_CompressXMLFiles;
+  bool                     CompressXMLFiles;
 
   void BlockTestErrorDiagnostics();
 
@@ -373,20 +373,20 @@ private:
   bool CheckArgument(const std::string& arg, const char* varg1,
     const char* varg2 = 0);
 
-  bool                      m_SuppressUpdatingCTestConfiguration;
+  bool                      SuppressUpdatingCTestConfiguration;
 
-  bool m_Debug;
-  bool m_ShowLineNumbers;
-  bool m_Quiet;
+  bool Debug;
+  bool ShowLineNumbers;
+  bool Quiet;
 
-  int  m_DartVersion;
+  int  DartVersion;
 
-  std::set<cmStdString> m_SubmitFiles;
+  std::set<cmStdString> SubmitFiles;
 
-  int m_SubmitIndex;
+  int SubmitIndex;
 
-  cmGeneratedFileStream* m_OutputLogFile;
-  int                    m_OutputLogFileLastTag;
+  cmGeneratedFileStream* OutputLogFile;
+  int OutputLogFileLastTag;
 };
 
 class cmCTestLogWrite
diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx
index f7d576b..7d3c151 100644
--- a/Source/cmCacheManager.cxx
+++ b/Source/cmCacheManager.cxx
@@ -183,7 +183,7 @@ bool cmCacheManager::LoadCache(const char* path,
   // clear the old cache, if we are reading in internal values
   if ( internal )
     {
-    m_Cache.clear();
+    this->Cache.clear();
     }
   if(!cmSystemTools::FileExists(cacheFile.c_str()))
     {
@@ -220,7 +220,7 @@ bool cmCacheManager::LoadCache(const char* path,
       }
     while(realbuffer[0] == '/' && realbuffer[1] == '/')
       {
-      e.m_Properties["HELPSTRING"] += &realbuffer[2];
+      e.Properties["HELPSTRING"] += &realbuffer[2];
       cmSystemTools::GetLineFromStream(fin, buffer);
       realbuffer = buffer.c_str();
       if(!fin)
@@ -228,7 +228,7 @@ bool cmCacheManager::LoadCache(const char* path,
         continue;
         }
       }
-    if(cmCacheManager::ParseEntry(realbuffer, entryKey, e.m_Value, e.m_Type))
+    if(cmCacheManager::ParseEntry(realbuffer, entryKey, e.Value, e.Type))
       {
       if ( excludes.find(entryKey) == excludes.end() )
         {
@@ -236,7 +236,7 @@ bool cmCacheManager::LoadCache(const char* path,
         // If the entry is not internal to the cache being loaded
         // or if it is in the list of internal entries to be
         // imported, load it.
-        if ( internal || (e.m_Type != INTERNAL) ||
+        if ( internal || (e.Type != INTERNAL) || 
              (includes.find(entryKey) != includes.end()) )
           {
           // If we are loading the cache from another project,
@@ -244,28 +244,28 @@ bool cmCacheManager::LoadCache(const char* path,
           // not visible in the gui
           if (!internal)
             {
-            e.m_Type = INTERNAL;
-            e.m_Properties["HELPSTRING"] = "DO NOT EDIT, ";
-            e.m_Properties["HELPSTRING"] += entryKey;
-            e.m_Properties["HELPSTRING"] += " loaded from external file.  "
+            e.Type = INTERNAL;
+            e.Properties["HELPSTRING"] = "DO NOT EDIT, ";
+            e.Properties["HELPSTRING"] += entryKey;
+            e.Properties["HELPSTRING"] += " loaded from external file.  "
               "To change this value edit this file: ";
-            e.m_Properties["HELPSTRING"] += path;
-            e.m_Properties["HELPSTRING"] += "/CMakeCache.txt"   ;
+            e.Properties["HELPSTRING"] += path;
+            e.Properties["HELPSTRING"] += "/CMakeCache.txt"   ;
             }
-          if ( e.m_Type == cmCacheManager::INTERNAL &&
+          if ( e.Type == cmCacheManager::INTERNAL &&
                (entryKey.size() > strlen("-ADVANCED")) &&
                strcmp(entryKey.c_str() + (entryKey.size() -
                    strlen("-ADVANCED")), "-ADVANCED") == 0 )
             {
-            std::string value = e.m_Value;
-            std::string akey
-              = entryKey.substr(0, (entryKey.size() - strlen("-ADVANCED")));
-            cmCacheManager::CacheIterator it
-              = this->GetCacheIterator(akey.c_str());
+            std::string value = e.Value;
+            std::string akey = 
+              entryKey.substr(0, (entryKey.size() - strlen("-ADVANCED")));
+            cmCacheManager::CacheIterator it = 
+              this->GetCacheIterator(akey.c_str());
             if ( it.IsAtEnd() )
               {
-              e.m_Type = cmCacheManager::UNINITIALIZED;
-              m_Cache[akey] = e;
+              e.Type = cmCacheManager::UNINITIALIZED;
+              this->Cache[akey] = e;
               }
             if (!it.Find(akey.c_str()))
               {
@@ -273,20 +273,20 @@ bool cmCacheManager::LoadCache(const char* path,
               }
             it.SetProperty("ADVANCED", value.c_str());
             }
-          else if ( e.m_Type == cmCacheManager::INTERNAL &&
+          else if ( e.Type == cmCacheManager::INTERNAL &&
                     (entryKey.size() > strlen("-MODIFIED")) &&
                     strcmp(entryKey.c_str() + (entryKey.size() -
                         strlen("-MODIFIED")), "-MODIFIED") == 0 )
             {
-            std::string value = e.m_Value;
-            std::string akey
-              = entryKey.substr(0, (entryKey.size() - strlen("-MODIFIED")));
-            cmCacheManager::CacheIterator it
-              = this->GetCacheIterator(akey.c_str());
+            std::string value = e.Value;
+            std::string akey = 
+              entryKey.substr(0, (entryKey.size() - strlen("-MODIFIED")));
+            cmCacheManager::CacheIterator it = 
+              this->GetCacheIterator(akey.c_str());
             if ( it.IsAtEnd() )
               {
-              e.m_Type = cmCacheManager::UNINITIALIZED;
-              m_Cache[akey] = e;
+              e.Type = cmCacheManager::UNINITIALIZED;
+              this->Cache[akey] = e;
               }
             if (!it.Find(akey.c_str()))
               {
@@ -296,8 +296,8 @@ bool cmCacheManager::LoadCache(const char* path,
             }
           else
             {
-            e.m_Initialized = true;
-            m_Cache[entryKey] = e;
+            e.Initialized = true;
+            this->Cache[entryKey] = e;
             }
           }
         }
@@ -400,8 +400,8 @@ bool cmCacheManager::SaveCache(const char* path)
     = this->GetCacheEntry("CMAKE_COMMAND");
   if ( cmakeCacheEntry )
     {
-    fout << "# It was generated by CMake: " << cmakeCacheEntry->m_Value
-      << std::endl;
+    fout << "# It was generated by CMake: " << 
+      cmakeCacheEntry->Value << std::endl;
     }
 
   fout << "# You can edit this file to change values found and used by cmake."
@@ -422,12 +422,12 @@ bool cmCacheManager::SaveCache(const char* path)
   fout << "########################\n";
   fout << "\n";
 
-  for( std::map<cmStdString, CacheEntry>::const_iterator i = m_Cache.begin();
-       i != m_Cache.end(); ++i)
+  for( std::map<cmStdString, CacheEntry>::const_iterator i = this->Cache.begin();
+       i != this->Cache.end(); ++i)
     {
-    const CacheEntry& ce = (*i).second;
-    CacheEntryType t = ce.m_Type;
-    if(t == cmCacheManager::UNINITIALIZED || !ce.m_Initialized)
+    const CacheEntry& ce = (*i).second; 
+    CacheEntryType t = ce.Type;
+    if(t == cmCacheManager::UNINITIALIZED || !ce.Initialized)
       {
       /*
         // This should be added in, but is not for now.
@@ -438,9 +438,9 @@ bool cmCacheManager::SaveCache(const char* path)
     else if(t != INTERNAL)
       {
       // Format is key:type=value
-      std::map<cmStdString,cmStdString>::const_iterator it =
-        ce.m_Properties.find("HELPSTRING");
-      if ( it == ce.m_Properties.end() )
+      std::map<cmStdString,cmStdString>::const_iterator it = 
+        ce.Properties.find("HELPSTRING");
+      if ( it == ce.Properties.end() )
         {
         cmCacheManager::OutputHelpString(fout, "Missing description");
         }
@@ -464,15 +464,15 @@ bool cmCacheManager::SaveCache(const char* path)
       fout << key.c_str() << ":"
            << cmCacheManagerTypes[t] << "=";
       // if value has trailing space or tab, enclose it in single quotes
-      if (ce.m_Value.size() &&
-          (ce.m_Value[ce.m_Value.size() - 1] == ' ' ||
-           ce.m_Value[ce.m_Value.size() - 1] == '\t'))
+      if (ce.Value.size() &&
+          (ce.Value[ce.Value.size() - 1] == ' ' || 
+           ce.Value[ce.Value.size() - 1] == '\t'))
         {
-        fout << '\'' << ce.m_Value << '\'';
+        fout << '\'' << ce.Value << '\'';
         }
       else
         {
-        fout << ce.m_Value;
+        fout << ce.Value;
         }
       fout << "\n\n";
       }
@@ -679,10 +679,10 @@ void cmCacheManager::OutputHelpString(std::ofstream& fout,
 
 void cmCacheManager::RemoveCacheEntry(const char* key)
 {
-  CacheEntryMap::iterator i = m_Cache.find(key);
-  if(i != m_Cache.end())
+  CacheEntryMap::iterator i = this->Cache.find(key);
+  if(i != this->Cache.end())
     {
-    m_Cache.erase(i);
+    this->Cache.erase(i);
     }
   else
     {
@@ -693,8 +693,8 @@ void cmCacheManager::RemoveCacheEntry(const char* key)
 
 cmCacheManager::CacheEntry *cmCacheManager::GetCacheEntry(const char* key)
 {
-  CacheEntryMap::iterator i = m_Cache.find(key);
-  if(i != m_Cache.end())
+  CacheEntryMap::iterator i = this->Cache.find(key);
+  if(i != this->Cache.end())
     {
     return &i->second;
     }
@@ -709,11 +709,11 @@ cmCacheManager::CacheIterator cmCacheManager::GetCacheIterator(
 
 const char* cmCacheManager::GetCacheValue(const char* key) const
 {
-  CacheEntryMap::const_iterator i = m_Cache.find(key);
-  if(i != m_Cache.end() &&
-    i->second.m_Initialized)
+  CacheEntryMap::const_iterator i = this->Cache.find(key);
+  if(i != this->Cache.end() &&
+    i->second.Initialized)
     {
-    return i->second.m_Value.c_str();
+    return i->second.Value.c_str();
     }
   return 0;
 }
@@ -723,13 +723,13 @@ void cmCacheManager::PrintCache(std::ostream& out) const
 {
   out << "=================================================" << std::endl;
   out << "CMakeCache Contents:" << std::endl;
-  for(std::map<cmStdString, CacheEntry>::const_iterator i = m_Cache.begin();
-      i != m_Cache.end(); ++i)
+  for(std::map<cmStdString, CacheEntry>::const_iterator i = this->Cache.begin();
+      i != this->Cache.end(); ++i)
     {
-    if((*i).second.m_Type != INTERNAL)
+    if((*i).second.Type != INTERNAL)
       {
-      out << (*i).first.c_str() << " = " << (*i).second.m_Value.c_str()
-        << std::endl;
+      out << (*i).first.c_str() << " = " << (*i).second.Value.c_str() 
+          << std::endl;
       }
     }
   out << "\n\n";
@@ -744,32 +744,32 @@ void cmCacheManager::AddCacheEntry(const char* key,
                                    const char* helpString,
                                    CacheEntryType type)
 {
-  CacheEntry& e = m_Cache[key];
+  CacheEntry& e = this->Cache[key];
   if ( value )
     {
-    e.m_Value = value;
-    e.m_Initialized = true;
+    e.Value = value;
+    e.Initialized = true;
     }
   else
     {
-    e.m_Value = "";
+    e.Value = "";
     }
-  e.m_Type = type;
+  e.Type = type;
   // make sure we only use unix style paths
   if(type == FILEPATH || type == PATH)
     {
-    cmSystemTools::ConvertToUnixSlashes(e.m_Value);
+    cmSystemTools::ConvertToUnixSlashes(e.Value);
     }
   if ( helpString )
     {
-    e.m_Properties["HELPSTRING"] = helpString;
+    e.Properties["HELPSTRING"] = helpString;
     }
   else
     {
-    e.m_Properties["HELPSTRING"]
-      = "(This variable does not exists and should not be used)";
+    e.Properties["HELPSTRING"] = 
+      "(This variable does not exists and should not be used)";
     }
-  m_Cache[key] = e;
+  this->Cache[key] = e;
 }
 
 void cmCacheManager::AddCacheEntry(const char* key, bool v,
@@ -787,17 +787,17 @@ void cmCacheManager::AddCacheEntry(const char* key, bool v,
 
 bool cmCacheManager::CacheIterator::IsAtEnd() const
 {
-  return m_Position == m_Container.m_Cache.end();
+  return this->Position == this->Container.Cache.end();
 }
 
 void cmCacheManager::CacheIterator::Begin()
 {
-  m_Position = m_Container.m_Cache.begin();
+  this->Position = this->Container.Cache.begin(); 
 }
 
 bool cmCacheManager::CacheIterator::Find(const char* key)
 {
-  m_Position = m_Container.m_Cache.find(key);
+  this->Position = this->Container.Cache.find(key);
   return !this->IsAtEnd();
 }
 
@@ -805,7 +805,7 @@ void cmCacheManager::CacheIterator::Next()
 {
   if (!this->IsAtEnd())
     {
-    ++m_Position;
+    ++this->Position; 
     }
 }
 
@@ -818,12 +818,12 @@ void cmCacheManager::CacheIterator::SetValue(const char* value)
   CacheEntry* entry = &this->GetEntry();
   if ( value )
     {
-    entry->m_Value = value;
-    entry->m_Initialized = true;
+    entry->Value = value;
+    entry->Initialized = true;
     }
   else
     {
-    entry->m_Value = "";
+    entry->Value = "";
     }
 }
 
@@ -843,9 +843,9 @@ const char* cmCacheManager::CacheIterator::GetProperty(
     return 0;
     }
   const CacheEntry* ent = &this->GetEntry();
-  std::map<cmStdString,cmStdString>::const_iterator it =
-    ent->m_Properties.find(property);
-  if ( it == ent->m_Properties.end() )
+  std::map<cmStdString,cmStdString>::const_iterator it = 
+    ent->Properties.find(property);
+  if ( it == ent->Properties.end() )
     {
     return 0;
     }
@@ -867,12 +867,13 @@ void cmCacheManager::CacheIterator::SetProperty(const char* p, const char* v)
     return;
     }
   CacheEntry* ent = &this->GetEntry();
-  ent->m_Properties[p] = v;
+  ent->Properties[p] = v;
 }
 
-bool cmCacheManager::CacheIterator::GetValueAsBool() const
-{
-  return cmSystemTools::IsOn(this->GetEntry().m_Value.c_str());
+
+bool cmCacheManager::CacheIterator::GetValueAsBool() const 
+{ 
+  return cmSystemTools::IsOn(this->GetEntry().Value.c_str()); 
 }
 
 bool cmCacheManager::CacheIterator::GetPropertyAsBool(
@@ -891,9 +892,9 @@ bool cmCacheManager::CacheIterator::GetPropertyAsBool(
     return false;
     }
   const CacheEntry* ent = &this->GetEntry();
-  std::map<cmStdString,cmStdString>::const_iterator it =
-    ent->m_Properties.find(property);
-  if ( it == ent->m_Properties.end() )
+  std::map<cmStdString,cmStdString>::const_iterator it = 
+    ent->Properties.find(property);
+  if ( it == ent->Properties.end() )
     {
     return false;
     }
@@ -916,7 +917,7 @@ void cmCacheManager::CacheIterator::SetProperty(const char* p, bool v)
     return;
     }
   CacheEntry* ent = &this->GetEntry();
-  ent->m_Properties[p] = v ? "ON" : "OFF";
+  ent->Properties[p] = v ? "ON" : "OFF";
 }
 
 bool cmCacheManager::CacheIterator::PropertyExists(const char* property) const
@@ -934,9 +935,9 @@ bool cmCacheManager::CacheIterator::PropertyExists(const char* property) const
     return false;
     }
   const CacheEntry* ent = &this->GetEntry();
-  std::map<cmStdString,cmStdString>::const_iterator it =
-    ent->m_Properties.find(property);
-  if ( it == ent->m_Properties.end() )
+  std::map<cmStdString,cmStdString>::const_iterator it = 
+    ent->Properties.find(property);
+  if ( it == ent->Properties.end() )
     {
     return false;
     }
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
index 2a2a71c..f36193a 100644
--- a/Source/cmCacheManager.h
+++ b/Source/cmCacheManager.h
@@ -37,11 +37,11 @@ public:
 private:
   struct CacheEntry
   {
-    std::string m_Value;
-    CacheEntryType m_Type;
-    std::map<cmStdString,cmStdString> m_Properties;
-    bool m_Initialized;
-    CacheEntry() : m_Value(""), m_Type(UNINITIALIZED), m_Initialized(false)
+    std::string Value;
+    CacheEntryType Type;
+    std::map<cmStdString,cmStdString> Properties;
+    bool Initialized;
+    CacheEntry() : Value(""), Type(UNINITIALIZED), Initialized(false)
       {}
   };
 
@@ -54,23 +54,23 @@ public:
     bool IsAtEnd() const;
     void Next();
     const char *GetName() const {
-      return m_Position->first.c_str(); } 
+      return this->Position->first.c_str(); } 
     const char* GetProperty(const char*) const ;
     bool GetPropertyAsBool(const char*) const ;
     bool PropertyExists(const char*) const;
     void SetProperty(const char* property, const char* value);
     void SetProperty(const char* property, bool value);
-    const char* GetValue() const { return this->GetEntry().m_Value.c_str(); }
+    const char* GetValue() const { return this->GetEntry().Value.c_str(); }
     bool GetValueAsBool() const;
     void SetValue(const char*);
-    CacheEntryType GetType() const { return this->GetEntry().m_Type; }
-    bool Initialized() { return this->GetEntry().m_Initialized; }
-    cmCacheManager &m_Container;
-    std::map<cmStdString, CacheEntry>::iterator m_Position;
-    CacheIterator(cmCacheManager &cm) : m_Container(cm) {
+    CacheEntryType GetType() const { return this->GetEntry().Type; }
+    bool Initialized() { return this->GetEntry().Initialized; }
+    cmCacheManager &Container;
+    std::map<cmStdString, CacheEntry>::iterator Position;
+    CacheIterator(cmCacheManager &cm) : Container(cm) {
       this->Begin();
     }
-    CacheIterator(cmCacheManager &cm, const char* key) : m_Container(cm) 
+    CacheIterator(cmCacheManager &cm, const char* key) : Container(cm) 
       {
       if ( key )
         {
@@ -78,8 +78,8 @@ public:
         }
     }
   private:
-    CacheEntry const& GetEntry() const { return m_Position->second; }
-    CacheEntry& GetEntry() { return m_Position->second; }
+    CacheEntry const& GetEntry() const { return this->Position->second; }
+    CacheEntry& GetEntry() { return this->Position->second; }
   };
   
   ///! return an iterator to iterate through the cache map
@@ -126,7 +126,7 @@ public:
   
   ///! Get the number of entries in the cache
   int GetSize() {
-    return static_cast<int>(m_Cache.size()); }
+    return static_cast<int>(this->Cache.size()); }
   
   ///! Break up a line like VAR:type="value" into var, type and value
   static bool ParseEntry(const char* entry, 
@@ -158,7 +158,7 @@ private:
   typedef  std::map<cmStdString, CacheEntry> CacheEntryMap;
   static void OutputHelpString(std::ofstream& fout, 
                                const std::string& helpString);
-  CacheEntryMap m_Cache;
+  CacheEntryMap Cache;
   // Only cmake and cmMakefile should be able to add cache values
   // the commands should never use the cmCacheManager directly
   friend class cmMakefile; // allow access to add cache values
diff --git a/Source/cmCommand.h b/Source/cmCommand.h
index 0143047..7466bb5 100644
--- a/Source/cmCommand.h
+++ b/Source/cmCommand.h
@@ -40,7 +40,7 @@ public:
    * Construct the command. By default it is enabled with no makefile.
    */
   cmCommand()  
-    {m_Makefile = 0; m_Enabled = true;}
+    {this->Makefile = 0; this->Enabled = true;}
 
   /**
    * Need virtual destructor to destroy real command type.
@@ -51,8 +51,8 @@ public:
    * Specify the makefile.
    */
   void SetMakefile(cmMakefile*m) 
-    {m_Makefile = m; }
-  cmMakefile* GetMakefile() { return m_Makefile; }
+    {this->Makefile = m; }
+  cmMakefile* GetMakefile() { return this->Makefile; }
 
   /**
    * This is called by the cmMakefile when the command is first
@@ -62,7 +62,7 @@ public:
   virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args)
     {
     std::vector<std::string> expandedArguments;
-    m_Makefile->ExpandArguments(args, expandedArguments);
+    this->Makefile->ExpandArguments(args, expandedArguments);
     return this->InitialPass(expandedArguments);
     }
 
@@ -120,37 +120,37 @@ public:
    * Enable the command.
    */
   void EnabledOn() 
-    {m_Enabled = true;}
+    {this->Enabled = true;}
 
   /**
    * Disable the command.
    */
   void EnabledOff() 
-    {m_Enabled = false;}
+    {this->Enabled = false;}
 
   /**
    * Query whether the command is enabled.
    */
   bool GetEnabled()  
-    {return m_Enabled;}
+    {return this->Enabled;}
 
   /**
    * Disable or enable the command.
    */
   void SetEnabled(bool enabled)  
-    {m_Enabled = enabled;}
+    {this->Enabled = enabled;}
 
   /**
    * Return the last error string.
    */
   const char* GetError() 
     {
-      if(m_Error.length() == 0)
+      if(this->Error.length() == 0)
         {
-        m_Error = this->GetName();
-        m_Error += " unknown error.";
+        this->Error = this->GetName();
+        this->Error += " unknown error.";
         }
-      return m_Error.c_str();
+      return this->Error.c_str();
     }
 
   /**
@@ -158,17 +158,17 @@ public:
    */
   void SetError(const char* e)
     {
-    m_Error = this->GetName();
-    m_Error += " ";
-    m_Error += e;
+    this->Error = this->GetName();
+    this->Error += " ";
+    this->Error += e;
     }
 
 protected:
-  cmMakefile* m_Makefile;
+  cmMakefile* Makefile;
 
 private:
-  bool m_Enabled;
-  std::string m_Error;
+  bool Enabled;
+  std::string Error;
 };
 
 #endif
diff --git a/Source/cmCommandArgumentLexer.cxx b/Source/cmCommandArgumentLexer.cxx
index 682ac74..47cb6d8 100644
--- a/Source/cmCommandArgumentLexer.cxx
+++ b/Source/cmCommandArgumentLexer.cxx
@@ -829,7 +829,7 @@ YY_RULE_SETUP
 {
   //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
   //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); 
-  yylvalp->str = yyextra->m_DCURLYVariable;
+  yylvalp->str = yyextra->DCURLYVariable;
   return cal_DCURLY;
 }
 case 4:
@@ -838,7 +838,7 @@ YY_RULE_SETUP
 {
   //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
   //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); 
-  yylvalp->str = yyextra->m_RCURLYVariable;
+  yylvalp->str = yyextra->RCURLYVariable;
   return cal_RCURLY;
 }
 case 5:
@@ -847,7 +847,7 @@ YY_RULE_SETUP
 {
   //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
   //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); 
-  yylvalp->str = yyextra->m_ATVariable;
+  yylvalp->str = yyextra->ATVariable;
   return cal_AT;
 }
 case 6:
@@ -882,7 +882,7 @@ YY_RULE_SETUP
 
 {
   //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); 
-  yylvalp->str = yyextra->m_DOLLARVariable;
+  yylvalp->str = yyextra->DOLLARVariable;
   return cal_DOLLAR; 
 }
 case 10:
@@ -890,7 +890,7 @@ YY_RULE_SETUP
 
 {
   //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); 
-  yylvalp->str = yyextra->m_LCURLYVariable;
+  yylvalp->str = yyextra->LCURLYVariable;
   return cal_LCURLY; 
 }
 case 11:
@@ -898,7 +898,7 @@ YY_RULE_SETUP
 
 {
   //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); 
-  yylvalp->str = yyextra->m_BSLASHVariable;
+  yylvalp->str = yyextra->BSLASHVariable;
   return cal_BSLASH; 
 }
 case 12:
@@ -1093,10 +1093,10 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
   else
     {
-      size_t num_to_read =
+      size_t nuto_read =
       YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
-    while ( num_to_read <= 0 )
+    while ( nuto_read <= 0 )
       { /* Not enough room in the buffer - grow it. */
 
       /* just a shorter name for the current buffer */
@@ -1128,17 +1128,17 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
       yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
 
-      num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+      nuto_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
             number_to_move - 1;
 
       }
 
-    if ( num_to_read > YY_READ_BUF_SIZE )
-      num_to_read = YY_READ_BUF_SIZE;
+    if ( nuto_read > YY_READ_BUF_SIZE )
+      nuto_read = YY_READ_BUF_SIZE;
 
     /* Read in more data. */
     YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-      yyg->yy_n_chars, num_to_read );
+      yyg->yy_n_chars, nuto_read );
 
     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
     }
@@ -1539,7 +1539,7 @@ void cmCommandArgument_yypop_buffer_state (yyscan_t yyscanner)
  */
 static void cmCommandArgument_yyensure_buffer_stack (yyscan_t yyscanner)
 {
-  int num_to_alloc;
+  int nuto_alloc;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
   if (!yyg->yy_buffer_stack) {
@@ -1548,14 +1548,14 @@ static void cmCommandArgument_yyensure_buffer_stack (yyscan_t yyscanner)
      * scanner will even need a stack. We use 2 instead of 1 to avoid an
      * immediate realloc on the next call.
          */
-    num_to_alloc = 1;
+    nuto_alloc = 1;
     yyg->yy_buffer_stack = (struct yy_buffer_state**)cmCommandArgument_yyalloc
-                (num_to_alloc * sizeof(struct yy_buffer_state*)
+                (nuto_alloc * sizeof(struct yy_buffer_state*)
                 , yyscanner);
     
-    memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+    memset(yyg->yy_buffer_stack, 0, nuto_alloc * sizeof(struct yy_buffer_state*));
         
-    yyg->yy_buffer_stack_max = num_to_alloc;
+    yyg->yy_buffer_stack_max = nuto_alloc;
     yyg->yy_buffer_stack_top = 0;
     return;
   }
@@ -1565,15 +1565,15 @@ static void cmCommandArgument_yyensure_buffer_stack (yyscan_t yyscanner)
     /* Increase the buffer to prepare for a possible push. */
     int grow_size = 8 /* arbitrary grow size */;
 
-    num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
+    nuto_alloc = yyg->yy_buffer_stack_max + grow_size;
     yyg->yy_buffer_stack = (struct yy_buffer_state**)cmCommandArgument_yyrealloc
                 (yyg->yy_buffer_stack,
-                num_to_alloc * sizeof(struct yy_buffer_state*)
+                nuto_alloc * sizeof(struct yy_buffer_state*)
                 , yyscanner);
 
     /* zero only the new slots.*/
     memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
-    yyg->yy_buffer_stack_max = num_to_alloc;
+    yyg->yy_buffer_stack_max = nuto_alloc;
   }
 }
 
diff --git a/Source/cmCommandArgumentParserHelper.cxx b/Source/cmCommandArgumentParserHelper.cxx
index f37eba2..31c4bc0 100644
--- a/Source/cmCommandArgumentParserHelper.cxx
+++ b/Source/cmCommandArgumentParserHelper.cxx
@@ -25,18 +25,18 @@ int cmCommandArgument_yyparse( yyscan_t yyscanner );
 //
 cmCommandArgumentParserHelper::cmCommandArgumentParserHelper()
 {
-  m_FileLine = -1;
-  m_FileName = 0;
+  this->FileLine = -1;
+  this->FileName = 0;
 
-  m_EmptyVariable[0] = 0;
-  strcpy(m_DCURLYVariable, "${");
-  strcpy(m_RCURLYVariable, "}");
-  strcpy(m_ATVariable,     "@");
-  strcpy(m_DOLLARVariable, "$");
-  strcpy(m_LCURLYVariable, "{");
-  strcpy(m_BSLASHVariable, "\\");
+  this->EmptyVariable[0] = 0;
+  strcpy(this->DCURLYVariable, "${");
+  strcpy(this->RCURLYVariable, "}");
+  strcpy(this->ATVariable,     "@");
+  strcpy(this->DOLLARVariable, "$");
+  strcpy(this->LCURLYVariable, "{");
+  strcpy(this->BSLASHVariable, "\\");
 
-  m_NoEscapeMode = false;
+  this->NoEscapeMode = false;
 }
 
 
@@ -47,19 +47,19 @@ cmCommandArgumentParserHelper::~cmCommandArgumentParserHelper()
 
 void cmCommandArgumentParserHelper::SetLineFile(long line, const char* file)
 {
-  m_FileLine = line;
-  m_FileName = file;
+  this->FileLine = line;
+  this->FileName = file;
 }
 
 char* cmCommandArgumentParserHelper::AddString(const char* str)
 {
   if ( !str || !*str )
     {
-    return m_EmptyVariable;
+    return this->EmptyVariable;
     }
   char* stVal = new char[strlen(str)+1];
   strcpy(stVal, str);
-  m_Variables.push_back(stVal);
+  this->Variables.push_back(stVal);
   return stVal;
 }
 
@@ -74,7 +74,7 @@ char* cmCommandArgumentParserHelper::ExpandSpecialVariable(const char* key, cons
     char *ptr = getenv(var);
     if (ptr)
       {
-      if (m_EscapeQuotes)
+      if (this->EscapeQuotes)
         {
         return this->AddString(cmSystemTools::EscapeQuotes(ptr).c_str());
         }
@@ -83,7 +83,7 @@ char* cmCommandArgumentParserHelper::ExpandSpecialVariable(const char* key, cons
         return ptr;
         }
       }
-    return m_EmptyVariable;
+    return this->EmptyVariable;
     }
   cmSystemTools::Error("Key ", key, " is not used yet. For now only $ENV{..} is allowed");
   return 0;
@@ -91,18 +91,18 @@ char* cmCommandArgumentParserHelper::ExpandSpecialVariable(const char* key, cons
 
 char* cmCommandArgumentParserHelper::ExpandVariable(const char* var)
 {
-  if(m_FileName && strcmp(var, "CMAKE_CURRENT_LIST_FILE") == 0)
+  if(this->FileName && strcmp(var, "CMAKE_CURRENT_LIST_FILE") == 0)
     {
-    return this->AddString(m_FileName);
+    return this->AddString(this->FileName);
     }
-  else if(m_FileLine >= 0 && strcmp(var, "CMAKE_CURRENT_LIST_LINE") == 0)
+  else if(this->FileLine >= 0 && strcmp(var, "CMAKE_CURRENT_LIST_LINE") == 0)
     {
     cmOStringStream ostr;
-    ostr << m_FileLine;
+    ostr << this->FileLine;
     return this->AddString(ostr.str().c_str());
     } 
-  const char* value = m_Makefile->GetDefinition(var);
-  if (m_EscapeQuotes && value)
+  const char* value = this->Makefile->GetDefinition(var);
+  if (this->EscapeQuotes && value)
     {
     return this->AddString(cmSystemTools::EscapeQuotes(value).c_str());
     }
@@ -123,7 +123,7 @@ char* cmCommandArgumentParserHelper::CombineUnions(char* in1, char* in2)
   char* out = new char [ len ];
   strcpy(out, in1);
   strcat(out, in2);
-  m_Variables.push_back(out);
+  this->Variables.push_back(out);
   return out;
 }
 
@@ -142,13 +142,13 @@ void cmCommandArgumentParserHelper::AllocateParserType(cmCommandArgumentParserHe
   pt->str = new char[ len + 1 ];
   strncpy(pt->str, str, len);
   pt->str[len] = 0;
-  m_Variables.push_back(pt->str);
+  this->Variables.push_back(pt->str);
   // std::cout << (void*) pt->str << " " << pt->str << " JPAllocateParserType" << std::endl;
 }
 
 bool cmCommandArgumentParserHelper::HandleEscapeSymbol(cmCommandArgumentParserHelper::ParserType* pt, char symbol)
 {
-  if ( m_NoEscapeMode )
+  if ( this->NoEscapeMode )
     {
     char buffer[3];
     buffer[0] = '\\';
@@ -207,7 +207,7 @@ int cmCommandArgumentParserHelper::ParseString(const char* str, int verb)
   this->InputBufferPos = 0;
   this->CurrentLine = 0;
   
-  m_Result = "";
+  this->Result = "";
 
   yyscan_t yyscanner;
   cmCommandArgument_yylex_init(&yyscanner);
@@ -225,7 +225,7 @@ int cmCommandArgumentParserHelper::ParseString(const char* str, int verb)
 
   if ( Verbose )
     {
-    std::cerr << "Expanding [" << str << "] produced: [" << m_Result.c_str() << "]" << std::endl;
+    std::cerr << "Expanding [" << str << "] produced: [" << this->Result.c_str() << "]" << std::endl;
     }
   return 1;
 }
@@ -233,13 +233,13 @@ int cmCommandArgumentParserHelper::ParseString(const char* str, int verb)
 void cmCommandArgumentParserHelper::CleanupParser()
 {
   std::vector<char*>::iterator sit;
-  for ( sit = m_Variables.begin();
-    sit != m_Variables.end();
+  for ( sit = this->Variables.begin();
+    sit != this->Variables.end();
     ++ sit )
     {
     delete [] *sit;
     }
-  m_Variables.erase(m_Variables.begin(), m_Variables.end());
+  this->Variables.erase(this->Variables.begin(), this->Variables.end());
 }
 
 int cmCommandArgumentParserHelper::LexInput(char* buf, int maxlen)
@@ -283,21 +283,21 @@ void cmCommandArgumentParserHelper::Error(const char* str)
     }
   std::cerr << "]" << std::endl;
   */
-  m_Error = ostr.str();
+  this->ErrorString = ostr.str();
 }
 
 void cmCommandArgumentParserHelper::SetMakefile(const cmMakefile* mf)
 {
-  m_Makefile = mf;
+  this->Makefile = mf;
 }
 
 void cmCommandArgumentParserHelper::SetResult(const char* value)
 {
   if ( !value )
     {
-    m_Result = "";
+    this->Result = "";
     return;
     }
-  m_Result = value;
+  this->Result = value;
 }
 
diff --git a/Source/cmCommandArgumentParserHelper.h b/Source/cmCommandArgumentParserHelper.h
index f366768..cb64393 100644
--- a/Source/cmCommandArgumentParserHelper.h
+++ b/Source/cmCommandArgumentParserHelper.h
@@ -63,21 +63,20 @@ public:
 
   void SetMakefile(const cmMakefile* mf);
 
-  std::string& GetResult() { return m_Result; }
+  std::string& GetResult() { return this->Result; }
 
   void SetLineFile(long line, const char* file);
-  void SetEscapeQuotes(bool b) { m_EscapeQuotes = b; }
-  void SetNoEscapeMode(bool b) { m_NoEscapeMode = b; }
-
-  const char* GetError() { return m_Error.c_str(); }
-
-  char m_EmptyVariable[1];
-  char m_DCURLYVariable[3];
-  char m_RCURLYVariable[3];
-  char m_ATVariable[3];
-  char m_DOLLARVariable[3];
-  char m_LCURLYVariable[3];
-  char m_BSLASHVariable[3];
+  void SetEscapeQuotes(bool b) { this->EscapeQuotes = b; }
+  void SetNoEscapeMode(bool b) { this->NoEscapeMode = b; }
+
+  const char* GetError() { return this->ErrorString.c_str(); } 
+  char EmptyVariable[1];
+  char DCURLYVariable[3];
+  char RCURLYVariable[3];
+  char ATVariable[3];
+  char DOLLARVariable[3];
+  char LCURLYVariable[3];
+  char BSLASHVariable[3];
 
 private:
   cmStdString::size_type InputBufferPos;
@@ -94,14 +93,14 @@ private:
 
   void CleanupParser();
 
-  std::vector<char*> m_Variables;
-  const cmMakefile* m_Makefile;
-  std::string m_Result;
-  const char* m_FileName;
-  long m_FileLine;
-  bool m_EscapeQuotes;
-  std::string m_Error;
-  bool m_NoEscapeMode;
+  std::vector<char*> Variables;
+  const cmMakefile* Makefile;
+  std::string Result;
+  const char* FileName;
+  long FileLine;
+  bool EscapeQuotes;
+  std::string ErrorString;
+  bool NoEscapeMode;
 };
 
 #endif
diff --git a/Source/cmConfigureFileCommand.cxx b/Source/cmConfigureFileCommand.cxx
index ec9527d..a3cf1dd 100644
--- a/Source/cmConfigureFileCommand.cxx
+++ b/Source/cmConfigureFileCommand.cxx
@@ -26,47 +26,47 @@ bool cmConfigureFileCommand::InitialPass(std::vector<std::string> const& args)
     this->SetError("called with incorrect number of arguments, expected 2");
     return false;
     }
-  m_InputFile = args[0];
-  m_OuputFile = args[1];
-  m_CopyOnly = false;
-  m_EscapeQuotes = false;
+  this->InputFile = args[0];
+  this->OuputFile = args[1];
+  this->CopyOnly = false;
+  this->EscapeQuotes = false;
 
   
   // for CMake 2.0 and earlier CONFIGURE_FILE defaults to the FinalPass,
   // after 2.0 it only does InitialPass
-  m_Immediate = false;
+  this->Immediate = false;
   const char* versionValue
-    = m_Makefile->GetRequiredDefinition("CMAKE_BACKWARDS_COMPATIBILITY");
+    = this->Makefile->GetRequiredDefinition("CMAKE_BACKWARDS_COMPATIBILITY");
   if (atof(versionValue) > 2.0)
     {
-    m_Immediate = true;
+    this->Immediate = true;
     }
 
   
-  m_AtOnly = false;
+  this->AtOnly = false;
   for(unsigned int i=2;i < args.size();++i)
     {
     if(args[i] == "COPYONLY")
       {
-      m_CopyOnly = true;
+      this->CopyOnly = true;
       }
     else if(args[i] == "ESCAPE_QUOTES")
       {
-      m_EscapeQuotes = true;
+      this->EscapeQuotes = true;
       }
     else if(args[i] == "@ONLY")
       {
-      m_AtOnly = true;
+      this->AtOnly = true;
       }
     else if(args[i] == "IMMEDIATE")
       {
-      m_Immediate = true;
+      this->Immediate = true;
       }
     }
   
   // If we were told to copy the file immediately, then do it on the
   // first pass (now).
-  if(m_Immediate)
+  if(this->Immediate)
     {
     if ( !this->ConfigureFile() )
       {
@@ -80,7 +80,7 @@ bool cmConfigureFileCommand::InitialPass(std::vector<std::string> const& args)
 
 void cmConfigureFileCommand::FinalPass()
 {
-  if(!m_Immediate)
+  if(!this->Immediate)
     {
     this->ConfigureFile();
     }
@@ -88,18 +88,18 @@ void cmConfigureFileCommand::FinalPass()
 
 int cmConfigureFileCommand::ConfigureFile()
 {
-  std::string inFile = m_InputFile;
+  std::string inFile = this->InputFile;
   if (!cmSystemTools::FileIsFullPath(inFile.c_str()))
     {
-    inFile = m_Makefile->GetStartDirectory();
+    inFile = this->Makefile->GetStartDirectory();
     inFile += "/";
-    inFile += m_InputFile;
+    inFile += this->InputFile;
     }
-  return m_Makefile->ConfigureFile(inFile.c_str(),
-    m_OuputFile.c_str(),
-    m_CopyOnly,
-    m_AtOnly,
-    m_EscapeQuotes);
+  return this->Makefile->ConfigureFile(inFile.c_str(),
+    this->OuputFile.c_str(),
+    this->CopyOnly,
+    this->AtOnly,
+    this->EscapeQuotes);
 }
 
 
diff --git a/Source/cmConfigureFileCommand.h b/Source/cmConfigureFileCommand.h
index e2dd493..ce0a5cd 100644
--- a/Source/cmConfigureFileCommand.h
+++ b/Source/cmConfigureFileCommand.h
@@ -81,12 +81,12 @@ public:
 private:
   int ConfigureFile();
   
-  std::string m_InputFile;
-  std::string m_OuputFile;
-  bool m_CopyOnly;
-  bool m_EscapeQuotes;
-  bool m_Immediate;
-  bool m_AtOnly;
+  std::string InputFile;
+  std::string OuputFile;
+  bool CopyOnly;
+  bool EscapeQuotes;
+  bool Immediate;
+  bool AtOnly;
 };
 
 
diff --git a/Source/cmCreateTestSourceList.cxx b/Source/cmCreateTestSourceList.cxx
index 678e600..02071dd 100644
--- a/Source/cmCreateTestSourceList.cxx
+++ b/Source/cmCreateTestSourceList.cxx
@@ -77,13 +77,14 @@ bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& args)
       "You must specify a file extenion for the test driver file.");
     return false;
     }
-  std::string driver = m_Makefile->GetCurrentOutputDirectory();
+  std::string driver = this->Makefile->GetCurrentOutputDirectory();
   driver += "/";
   driver += *i;
   ++i;
 
   std::string configFile =
-    m_Makefile->GetRequiredDefinition("CMAKE_ROOT");
+    this->Makefile->GetRequiredDefinition("CMAKE_ROOT");
+
   configFile += "/Templates/TestDriver.cxx.in";
   // Create the test driver file
 
@@ -150,20 +151,20 @@ bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& args)
     }
   if(extraInclude.size())
     {
-    m_Makefile->AddDefinition("CMAKE_TESTDRIVER_EXTRA_INCLUDES",
-      extraInclude.c_str());
+    this->Makefile->AddDefinition("CMAKE_TESTDRIVER_EXTRA_INCLUDES",
+                                  extraInclude.c_str());
     }
   if(function.size())
     {
-    m_Makefile->AddDefinition("CMAKE_TESTDRIVER_ARGVC_FUNCTION",
-      function.c_str());
+    this->Makefile->AddDefinition("CMAKE_TESTDRIVER_ARGVC_FUNCTION",
+                                  function.c_str());
     }
-  m_Makefile->AddDefinition("CMAKE_FORWARD_DECLARE_TESTS",
+  this->Makefile->AddDefinition("CMAKE_FORWARD_DECLARE_TESTS",
     forwardDeclareCode.c_str());
-  m_Makefile->AddDefinition("CMAKE_FUNCTION_TABLE_ENTIRES",
+  this->Makefile->AddDefinition("CMAKE_FUNCTION_TABLE_ENTIRES",
     functionMapCode.c_str());
   bool res = true;
-  if ( !m_Makefile->ConfigureFile(configFile.c_str(), driver.c_str(),
+  if ( !this->Makefile->ConfigureFile(configFile.c_str(), driver.c_str(),
       false, true, false) )
     {
     res = false;
@@ -175,10 +176,10 @@ bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& args)
 
   cfile.SetProperty("ABSTRACT","0");
   cfile.SetName(cmSystemTools::GetFilenameWithoutExtension(args[1]).c_str(),
-                m_Makefile->GetCurrentOutputDirectory(),
+                this->Makefile->GetCurrentOutputDirectory(),
                 cmSystemTools::GetFilenameExtension(args[1]).c_str()+1,
                 false);
-  m_Makefile->AddSource(cfile);
+  this->Makefile->AddSource(cfile);
   sourceListValue = args[1];
 
   for(i = testsBegin; i != tests.end(); ++i)
@@ -186,15 +187,15 @@ bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& args)
     cmSourceFile icfile;
     icfile.SetProperty("ABSTRACT","0");
     icfile.SetName(i->c_str(),
-                  m_Makefile->GetCurrentDirectory(),
-                  m_Makefile->GetSourceExtensions(),
-                  m_Makefile->GetHeaderExtensions());
-    m_Makefile->AddSource(icfile);
+                  this->Makefile->GetCurrentDirectory(),
+                  this->Makefile->GetSourceExtensions(),
+                  this->Makefile->GetHeaderExtensions());
+    this->Makefile->AddSource(icfile);
     sourceListValue += ";";
     sourceListValue += *i;
     }
 
-  m_Makefile->AddDefinition(sourceList, sourceListValue.c_str());
+  this->Makefile->AddDefinition(sourceList, sourceListValue.c_str());
   return res;
 }
 
diff --git a/Source/cmCustomCommand.cxx b/Source/cmCustomCommand.cxx
index 4278c7d..b66568c 100644
--- a/Source/cmCustomCommand.cxx
+++ b/Source/cmCustomCommand.cxx
@@ -19,65 +19,65 @@
 //----------------------------------------------------------------------------
 cmCustomCommand::cmCustomCommand()
 {
-  m_Used = false;
+  this->Used = false;
 }
 
 //----------------------------------------------------------------------------
 cmCustomCommand::cmCustomCommand(const cmCustomCommand& r):
-  m_Output(r.m_Output),
-  m_Depends(r.m_Depends),
-  m_CommandLines(r.m_CommandLines),
-  m_Comment(r.m_Comment),
-  m_WorkingDirectory(r.m_WorkingDirectory)
+  Output(r.Output),
+  Depends(r.Depends),
+  CommandLines(r.CommandLines),
+  Comment(r.Comment),
+  WorkingDirectory(r.WorkingDirectory)
 {
-  m_Used = false;
+  this->Used = false;
 }
 
 //----------------------------------------------------------------------------
 cmCustomCommand::cmCustomCommand(const char* output,
                                  const std::vector<std::string>& depends,
                                  const cmCustomCommandLines& commandLines,
-                                 const char* comment,
+                                 const char* comment, 
                                  const char* workingDirectory):
-  m_Output(output?output:""),
-  m_Depends(depends),
-  m_CommandLines(commandLines),
-  m_Comment(comment?comment:""),
-  m_WorkingDirectory(workingDirectory?workingDirectory:"")
+  Output(output?output:""),
+  Depends(depends),
+  CommandLines(commandLines),
+  Comment(comment?comment:""),
+  WorkingDirectory(workingDirectory?workingDirectory:"")
 {
-  m_Used = false;
+  this->Used = false;
 }
 
 //----------------------------------------------------------------------------
 const char* cmCustomCommand::GetOutput() const
 {
-  return m_Output.c_str();
+  return this->Output.c_str();
 }
 
 //----------------------------------------------------------------------------
 const char* cmCustomCommand::GetWorkingDirectory() const
 {
-  if(m_WorkingDirectory.size() == 0)
+  if(this->WorkingDirectory.size() == 0)
     {
     return 0;
     }
-  return m_WorkingDirectory.c_str();
+  return this->WorkingDirectory.c_str();
 }
 
 //----------------------------------------------------------------------------
 const std::vector<std::string>& cmCustomCommand::GetDepends() const
 {
-  return m_Depends;
+  return this->Depends;
 }
 
 //----------------------------------------------------------------------------
 const cmCustomCommandLines& cmCustomCommand::GetCommandLines() const
 {
-  return m_CommandLines;
+  return this->CommandLines;
 }
 
 //----------------------------------------------------------------------------
 const char* cmCustomCommand::GetComment() const
 {
-  return m_Comment.c_str();
+  return this->Comment.c_str();
 }
diff --git a/Source/cmCustomCommand.h b/Source/cmCustomCommand.h
index e48d531..a33f123 100644
--- a/Source/cmCustomCommand.h
+++ b/Source/cmCustomCommand.h
@@ -54,16 +54,16 @@ public:
   const char* GetComment() const;
 
   /** set get the used status of the command */ 
-  void Used() { m_Used = true;}; 
-  bool IsUsed() { return m_Used;};
+  void SetUsed() { this->Used = true;}; 
+  bool IsUsed() { return this->Used;};
  
 private:
-  std::string m_Output;
-  std::vector<std::string> m_Depends;
-  cmCustomCommandLines m_CommandLines;
-  std::string m_Comment;
-  std::string m_WorkingDirectory;
-  bool m_Used;
+  std::string Output;
+  std::vector<std::string> Depends;
+  cmCustomCommandLines CommandLines;
+  std::string Comment;
+  std::string WorkingDirectory;
+  bool Used;
 };
 
 #endif
diff --git a/Source/cmDepends.cxx b/Source/cmDepends.cxx
index 42666a4..7ea0e7e 100644
--- a/Source/cmDepends.cxx
+++ b/Source/cmDepends.cxx
@@ -22,18 +22,18 @@
 #include <string.h>
 
 //----------------------------------------------------------------------------
-cmDepends::cmDepends(): m_Verbose(false), m_FileComparison(0),
-  m_MaxPath(cmSystemTools::GetMaximumFilePathLength()),
-  m_Dependee(new char[m_MaxPath]),
-  m_Depender(new char[m_MaxPath])
+cmDepends::cmDepends(): Verbose(false), FileComparison(0),
+  MaxPath(cmSystemTools::GetMaximumFilePathLength()),
+  Dependee(new char[MaxPath]),
+  Depender(new char[MaxPath])
 {
 }
 
 //----------------------------------------------------------------------------
 cmDepends::~cmDepends()
 {
-  delete [] m_Dependee;
-  delete [] m_Depender;
+  delete [] this->Dependee;
+  delete [] this->Depender;
 }
 
 //----------------------------------------------------------------------------
@@ -48,12 +48,12 @@ void cmDepends::Check(const char *makeFile, const char *internalFile)
 {
   // Dependency checks must be done in proper working directory.
   std::string oldcwd = ".";
-  if(m_CompileDirectory != ".")
+  if(this->CompileDirectory != ".")
     {
     // Get the CWD but do not call CollapseFullPath because
     // we only need it to cd back, and the form does not matter
     oldcwd = cmSystemTools::GetCurrentWorkingDirectory(false);
-    cmSystemTools::ChangeDirectory(m_CompileDirectory.c_str());
+    cmSystemTools::ChangeDirectory(this->CompileDirectory.c_str());
     }
 
   // Check whether dependencies must be regenerated.
@@ -76,7 +76,7 @@ void cmDepends::Check(const char *makeFile, const char *internalFile)
 void cmDepends::Clear(const char *file)
 {
   // Print verbose output.
-  if(m_Verbose)
+  if(this->Verbose)
     {
     cmOStringStream msg;
     msg << "Clearing dependencies in \"" << file << "\"." << std::endl;
@@ -103,21 +103,21 @@ bool cmDepends::CheckDependencies(std::istream& internalDepends)
   // or newer than the depender then dependencies should be
   // regenerated.
   bool okay = true;
-  while(internalDepends.getline(m_Dependee, m_MaxPath))
+  while(internalDepends.getline(this->Dependee, this->MaxPath))
     {
-    if ( m_Dependee[0] == 0 || m_Dependee[0] == '#' || m_Dependee[0] == '\r' )
+    if ( this->Dependee[0] == 0 || this->Dependee[0] == '#' || this->Dependee[0] == '\r' )
       {
       continue;
       }
     size_t len = internalDepends.gcount()-1;
-    if ( m_Dependee[len-1] == '\r' )
+    if ( this->Dependee[len-1] == '\r' )
       {
       len --;
-      m_Dependee[len] = 0;
+      this->Dependee[len] = 0;
       }
-    if ( m_Dependee[0] != ' ' )
+    if ( this->Dependee[0] != ' ' )
       {
-      memcpy(m_Depender, m_Dependee, len+1);
+      memcpy(this->Depender, this->Dependee, len+1);
       continue;
       }
     /*
@@ -131,15 +131,15 @@ bool cmDepends::CheckDependencies(std::istream& internalDepends)
     // Dependencies must be regenerated if the dependee does not exist
     // or if the depender exists and is older than the dependee.
     bool regenerate = false;
-    const char* dependee = m_Dependee+1;
-    const char* depender = m_Depender;
+    const char* dependee = this->Dependee+1;
+    const char* depender = this->Depender;
     if(!cmSystemTools::FileExists(dependee))
       {
       // The dependee does not exist.
       regenerate = true;
 
       // Print verbose output.
-      if(m_Verbose)
+      if(this->Verbose)
         {
         cmOStringStream msg;
         msg << "Dependee \"" << dependee
@@ -152,14 +152,14 @@ bool cmDepends::CheckDependencies(std::istream& internalDepends)
       {
       // The dependee and depender both exist.  Compare file times.
       int result = 0;
-      if((!m_FileComparison->FileTimeCompare(depender, dependee,
+      if((!this->FileComparison->FileTimeCompare(depender, dependee,
                                              &result) || result < 0))
         {
         // The depender is older than the dependee.
         regenerate = true;
 
         // Print verbose output.
-        if(m_Verbose)
+        if(this->Verbose)
           {
           cmOStringStream msg;
           msg << "Dependee \"" << dependee
diff --git a/Source/cmDepends.h b/Source/cmDepends.h
index 5196b6b..a0b1b6b 100644
--- a/Source/cmDepends.h
+++ b/Source/cmDepends.h
@@ -36,10 +36,10 @@ public:
   cmDepends();
   
   /** at what level will the compile be done from */
-  void SetCompileDirectory(const char *dir) {m_CompileDirectory = dir;};
+  void SetCompileDirectory(const char *dir) {this->CompileDirectory = dir;};
     
   /** should this be verbose in its output */
-  void SetVerbose(bool verb) { m_Verbose = verb; }
+  void SetVerbose(bool verb) { this->Verbose = verb; }
     
   /** Virtual destructor to cleanup subclasses properly.  */
   virtual ~cmDepends();
@@ -55,7 +55,8 @@ public:
   void Clear(const char *file);
 
   /** Set the file comparison object */
-  void SetFileComparison(cmFileTimeComparison* fc) { m_FileComparison = fc; }
+  void SetFileComparison(cmFileTimeComparison* fc) { 
+    this->FileComparison = fc; }
 
 protected:
 
@@ -70,16 +71,16 @@ protected:
   virtual bool CheckDependencies(std::istream& internalDepends);
 
   // The directory in which the build rule for the target file is executed.
-  std::string m_Directory;
-  std::string m_CompileDirectory;
+  std::string Directory;
+  std::string CompileDirectory;
 
   // Flag for verbose output.
-  bool m_Verbose;
-  cmFileTimeComparison* m_FileComparison;
+  bool Verbose;
+  cmFileTimeComparison* FileComparison;
 
-  size_t m_MaxPath;
-  char* m_Dependee;
-  char* m_Depender;
+  size_t MaxPath;
+  char* Dependee;
+  char* Depender;
 
 private:
   cmDepends(cmDepends const&); // Purposely not implemented.
diff --git a/Source/cmDependsC.cxx b/Source/cmDependsC.cxx
index 604e479..b21d1de 100644
--- a/Source/cmDependsC.cxx
+++ b/Source/cmDependsC.cxx
@@ -23,7 +23,7 @@
 
 //----------------------------------------------------------------------------
 cmDependsC::cmDependsC():
-  m_IncludePath(0), m_GeneratedFiles(0)
+  IncludePath(0), GeneratedFiles(0)
 {
 }
 
@@ -33,12 +33,12 @@ cmDependsC::cmDependsC(std::vector<std::string> const& includes,
                        const char* scanRegex, const char* complainRegex,
                        std::set<cmStdString> const& generatedFiles,
                        const cmStdString& cacheFileName):
-  m_IncludePath(&includes),
-  m_IncludeRegexLine("^[ \t]*#[ \t]*include[ \t]*[<\"]([^\">]+)([\">])"),
-  m_IncludeRegexScan(scanRegex),
-  m_IncludeRegexComplain(complainRegex),
-  m_GeneratedFiles(&generatedFiles),
-  m_cacheFileName(cacheFileName)
+  IncludePath(&includes),
+  IncludeRegexLine("^[ \t]*#[ \t]*include[ \t]*[<\"]([^\">]+)([\">])"),
+  IncludeRegexScan(scanRegex),
+  IncludeRegexComplain(complainRegex),
+  GeneratedFiles(&generatedFiles),
+  cacheFileName(cacheFileName)
 {
   this->ReadCacheFile();
 }
@@ -48,9 +48,8 @@ cmDependsC::~cmDependsC()
 {
   this->WriteCacheFile();
 
-  for (std::map<cmStdString, cmIncludeLines*>::iterator it
-    = m_fileCache.begin();
-       it!=m_fileCache.end(); ++it)
+  for (std::map<cmStdString, cmIncludeLines*>::iterator it=
+         this->fileCache.begin(); it!=this->fileCache.end(); ++it)
     {
     delete it->second;
     }
@@ -71,7 +70,7 @@ bool cmDependsC::WriteDependencies(const char *src, const char *obj,
     cmSystemTools::Error("Cannot scan dependencies without an object file.");
     return false;
     }
-  if(!m_IncludePath)
+  if(!this->IncludePath)
     {
     cmSystemTools::Error("Cannot scan dependencies without an include path.");
     return false;
@@ -81,16 +80,16 @@ bool cmDependsC::WriteDependencies(const char *src, const char *obj,
   bool first = true;
   UnscannedEntry root;
   root.FileName = src;
-  m_Unscanned.push(root);
-  m_Encountered.clear();
-  m_Encountered.insert(src);
+  this->Unscanned.push(root);
+  this->Encountered.clear();
+  this->Encountered.insert(src);
   std::set<cmStdString> dependencies;
   std::set<cmStdString> scanned;
-  while(!m_Unscanned.empty())
+  while(!this->Unscanned.empty())
     {
     // Get the next file to scan.
-    UnscannedEntry current = m_Unscanned.front();
-    m_Unscanned.pop();
+    UnscannedEntry current = this->Unscanned.front();
+    this->Unscanned.pop();
 
     // If not a full path, find the file in the include path.
     std::string fullName;
@@ -113,8 +112,8 @@ bool cmDependsC::WriteDependencies(const char *src, const char *obj,
       }
     else
       {
-      for(std::vector<std::string>::const_iterator i = m_IncludePath->begin();
-          i != m_IncludePath->end(); ++i)
+      for(std::vector<std::string>::const_iterator i = this->IncludePath->begin();
+          i != this->IncludePath->end(); ++i)
         {
         // Construct the name of the file as if it were in the current
         // include directory.  Avoid using a leading "./".
@@ -141,7 +140,7 @@ bool cmDependsC::WriteDependencies(const char *src, const char *obj,
     // Complain if the file cannot be found and matches the complain
     // regex.
     if(fullName.empty() &&
-       m_IncludeRegexComplain.find(current.FileName.c_str()))
+       this->IncludeRegexComplain.find(current.FileName.c_str()))
       {
       cmSystemTools::Error("Cannot find file \"",
                            current.FileName.c_str(), "\".");
@@ -155,20 +154,21 @@ bool cmDependsC::WriteDependencies(const char *src, const char *obj,
       scanned.insert(fullName);
 
       // Check whether this file is already in the cache
-      std::map<cmStdString, cmIncludeLines*>::iterator fileIt
-        = m_fileCache.find(fullName);
-      if (fileIt!=m_fileCache.end())
+      std::map<cmStdString, cmIncludeLines*>::iterator fileIt=
+        this->fileCache.find(fullName);
+      if (fileIt!=this->fileCache.end())
         {
-        fileIt->second->m_Used=true;
+        fileIt->second->Used=true;
         dependencies.insert(fullName);
         for (std::vector<UnscannedEntry>::const_iterator incIt=
-               fileIt->second->m_UnscannedEntries.begin();
-             incIt!=fileIt->second->m_UnscannedEntries.end(); ++incIt)
+               fileIt->second->UnscannedEntries.begin(); 
+             incIt!=fileIt->second->UnscannedEntries.end(); ++incIt)
           {
-          if (m_Encountered.find(incIt->FileName) == m_Encountered.end())
+          if (this->Encountered.find(incIt->FileName) == 
+              this->Encountered.end())
             {
-            m_Encountered.insert(incIt->FileName);
-            m_Unscanned.push(*incIt);
+            this->Encountered.insert(incIt->FileName);
+            this->Unscanned.push(*incIt);
             }
           }
         }
@@ -212,11 +212,11 @@ bool cmDependsC::WriteDependencies(const char *src, const char *obj,
 //----------------------------------------------------------------------------
 void cmDependsC::ReadCacheFile()
 {
-  if(m_cacheFileName.size() == 0)
+  if(this->cacheFileName.size() == 0)
     {
     return;
     }
-  std::ifstream fin(m_cacheFileName.c_str());
+  std::ifstream fin(this->cacheFileName.c_str());
   if(!fin)
     {
     return;
@@ -240,13 +240,13 @@ void cmDependsC::ReadCacheFile()
       haveFileName=true;
       int newer=0;
       cmFileTimeComparison comp;
-      bool res
-        = comp.FileTimeCompare(m_cacheFileName.c_str(), line.c_str(), &newer);
-
+      bool res=comp.FileTimeCompare(this->cacheFileName.c_str(), 
+                                    line.c_str(), &newer);
+      
       if ((res==true) && (newer==1)) //cache is newer than the parsed file
         {
         cacheEntry=new cmIncludeLines;
-        m_fileCache[line]=cacheEntry;
+        this->fileCache[line]=cacheEntry; 
         }
       }
     else if (cacheEntry!=0)
@@ -259,7 +259,7 @@ void cmDependsC::ReadCacheFile()
           {
           entry.QuotedLocation=line;
           }
-        cacheEntry->m_UnscannedEntries.push_back(entry);
+        cacheEntry->UnscannedEntries.push_back(entry);
         }
       }
     }
@@ -268,27 +268,27 @@ void cmDependsC::ReadCacheFile()
 //----------------------------------------------------------------------------
 void cmDependsC::WriteCacheFile() const
 {
-  if(m_cacheFileName.size() == 0)
+  if(this->cacheFileName.size() == 0)
     {
     return;
     }
-  std::ofstream cacheOut(m_cacheFileName.c_str());
+  std::ofstream cacheOut(this->cacheFileName.c_str());
   if(!cacheOut)
     {
     return;
     }
-
-  for (std::map<cmStdString, cmIncludeLines*>::const_iterator fileIt
-    = m_fileCache.begin();
-       fileIt!=m_fileCache.end(); ++fileIt)
+  
+  for (std::map<cmStdString, cmIncludeLines*>::const_iterator fileIt=
+         this->fileCache.begin(); 
+       fileIt!=this->fileCache.end(); ++fileIt)
     {
-    if (fileIt->second->m_Used)
+    if (fileIt->second->Used)
       {
       cacheOut<<fileIt->first.c_str()<<std::endl;
 
       for (std::vector<UnscannedEntry>::const_iterator
-             incIt=fileIt->second->m_UnscannedEntries.begin();
-           incIt!=fileIt->second->m_UnscannedEntries.end(); ++incIt)
+             incIt=fileIt->second->UnscannedEntries.begin(); 
+           incIt!=fileIt->second->UnscannedEntries.end(); ++incIt)
         {
         cacheOut<<incIt->FileName.c_str()<<std::endl;
         if (incIt->QuotedLocation.empty())
@@ -310,20 +310,20 @@ void cmDependsC::Scan(std::istream& is, const char* directory,
   const cmStdString& fullName)
 {
   cmIncludeLines* newCacheEntry=new cmIncludeLines;
-  newCacheEntry->m_Used=true;
-  m_fileCache[fullName]=newCacheEntry;
-
+  newCacheEntry->Used=true;
+  this->fileCache[fullName]=newCacheEntry;
+  
   // Read one line at a time.
   std::string line;
   while(cmSystemTools::GetLineFromStream(is, line))
     {
     // Match include directives.
-    if(m_IncludeRegexLine.find(line.c_str()))
+    if(this->IncludeRegexLine.find(line.c_str()))
       {
       // Get the file being included.
       UnscannedEntry entry;
-      entry.FileName = m_IncludeRegexLine.match(1);
-      if(m_IncludeRegexLine.match(2) == "\"" &&
+      entry.FileName = this->IncludeRegexLine.match(1);
+      if(this->IncludeRegexLine.match(2) == "\"" &&
          !cmSystemTools::FileIsFullPath(entry.FileName.c_str()))
         {
         // This was a double-quoted include with a relative path.  We
@@ -341,13 +341,13 @@ void cmDependsC::Scan(std::istream& is, const char* directory,
       // is included by double-quotes and the other by angle brackets.
       // This kind of problem will be fixed when a more
       // preprocessor-like implementation of this scanner is created.
-      if (m_IncludeRegexScan.find(entry.FileName.c_str()))
+      if (this->IncludeRegexScan.find(entry.FileName.c_str()))
         {
-        newCacheEntry->m_UnscannedEntries.push_back(entry);
-        if(m_Encountered.find(entry.FileName) == m_Encountered.end())
+        newCacheEntry->UnscannedEntries.push_back(entry);
+        if(this->Encountered.find(entry.FileName) == this->Encountered.end())
           {
-          m_Encountered.insert(entry.FileName);
-          m_Unscanned.push(entry);
+          this->Encountered.insert(entry.FileName);
+          this->Unscanned.push(entry);
           }
         }
       }
@@ -367,7 +367,7 @@ bool cmDependsC::FileExistsOrIsGenerated(const std::string& fname,
   else if(cmSystemTools::FileIsFullPath(fname.c_str()))
     {
     // The generated file may have been listed with a relative path.
-    std::string dir = cmSystemTools::CollapseFullPath(m_Directory.c_str());
+    std::string dir = cmSystemTools::CollapseFullPath(this->Directory.c_str());
     std::string rname =
       cmSystemTools::RelativePath(dir.c_str(), fname.c_str());
     if(this->FileIsGenerated(rname, scanned, dependencies))
@@ -385,9 +385,9 @@ bool cmDependsC::FileIsGenerated(const std::string& fname,
                                  std::set<cmStdString>& scanned,
                                  std::set<cmStdString>& dependencies)
 {
-  if(m_GeneratedFiles &&
-     std::set<cmStdString>::const_iterator(m_GeneratedFiles->find(fname)) !=
-     m_GeneratedFiles->end())
+  if(this->GeneratedFiles &&
+     std::set<cmStdString>::const_iterator(this->GeneratedFiles->find(fname)) !=
+     this->GeneratedFiles->end())
     {
     // If the file does not really exist yet pretend it has already
     // been scanned.  When it exists later then dependencies will be
diff --git a/Source/cmDependsC.h b/Source/cmDependsC.h
index 6c80db3..3fb3906 100644
--- a/Source/cmDependsC.h
+++ b/Source/cmDependsC.h
@@ -60,18 +60,18 @@ protected:
                        std::set<cmStdString>& dependencies);
 
   // The include file search path.
-  std::vector<std::string> const* m_IncludePath;
+  std::vector<std::string> const* IncludePath;
 
   // Regular expression to identify C preprocessor include directives.
-  cmsys::RegularExpression m_IncludeRegexLine;
+  cmsys::RegularExpression IncludeRegexLine;
 
   // Regular expressions to choose which include files to scan
   // recursively and which to complain about not finding.
-  cmsys::RegularExpression m_IncludeRegexScan;
-  cmsys::RegularExpression m_IncludeRegexComplain;
+  cmsys::RegularExpression IncludeRegexScan;
+  cmsys::RegularExpression IncludeRegexComplain;
 
   // Set of generated files available.
-  std::set<cmStdString> const* m_GeneratedFiles;
+  std::set<cmStdString> const* GeneratedFiles;
 public:
   // Data structures for dependency graph walk.
   struct UnscannedEntry
@@ -82,18 +82,18 @@ public:
 
   struct cmIncludeLines
   {
-    cmIncludeLines(): m_Used(false) {}
-    std::vector<UnscannedEntry> m_UnscannedEntries;
-    bool m_Used;
+    cmIncludeLines(): Used(false) {}
+    std::vector<UnscannedEntry> UnscannedEntries;
+    bool Used;
   };
 protected:
-  std::set<cmStdString> m_Encountered;
-  std::queue<UnscannedEntry> m_Unscanned;
-  t_CharBuffer m_Buffer;
+  std::set<cmStdString> Encountered;
+  std::queue<UnscannedEntry> Unscanned;
+  t_CharBuffer Buffer;
 
-  std::map<cmStdString, cmIncludeLines *> m_fileCache;
+  std::map<cmStdString, cmIncludeLines *> fileCache;
 
-  cmStdString m_cacheFileName;
+  cmStdString cacheFileName;
 
   void WriteCacheFile() const;
   void ReadCacheFile();
diff --git a/Source/cmDependsFortran.cxx b/Source/cmDependsFortran.cxx
index 1576be3..22cff0e 100644
--- a/Source/cmDependsFortran.cxx
+++ b/Source/cmDependsFortran.cxx
@@ -77,13 +77,13 @@ struct cmDependsFortranParser_s
 
 //----------------------------------------------------------------------------
 cmDependsFortran::cmDependsFortran():
-  m_IncludePath(0)
+  IncludePath(0)
 {
 }
 
 //----------------------------------------------------------------------------
 cmDependsFortran::cmDependsFortran(std::vector<std::string> const& includes):
-  m_IncludePath(&includes)
+  IncludePath(&includes)
 {
 }
 
@@ -107,7 +107,7 @@ bool cmDependsFortran::WriteDependencies(const char *src, const char *obj,
     cmSystemTools::Error("Cannot scan dependencies without an object file.");
     return false;
     }
-  if(!m_IncludePath)
+  if(!this->IncludePath)
     {
     cmSystemTools::Error("Cannot scan dependencies without an include path.");
     return false;
@@ -311,8 +311,8 @@ bool cmDependsFortran::FindIncludeFile(const char* dir,
       }
 
     // Search the include path for the file.
-    for(std::vector<std::string>::const_iterator i = m_IncludePath->begin();
-        i != m_IncludePath->end(); ++i)
+    for(std::vector<std::string>::const_iterator i = this->IncludePath->begin();
+        i != this->IncludePath->end(); ++i)
       {
       fullName = *i;
       fullName += "/";
diff --git a/Source/cmDependsFortran.h b/Source/cmDependsFortran.h
index b6a738c..e00681e 100644
--- a/Source/cmDependsFortran.h
+++ b/Source/cmDependsFortran.h
@@ -56,10 +56,10 @@ protected:
     std::ostream& makeDepends, std::ostream& internalDepends);
 
   // The source file from which to start scanning.
-  std::string m_SourceFile;
+  std::string SourceFile;
 
   // The include file search path.
-  std::vector<std::string> const* m_IncludePath;
+  std::vector<std::string> const* IncludePath;
 
 private:
   cmDependsFortran(cmDependsFortran const&); // Purposely not implemented.
diff --git a/Source/cmDependsFortranLexer.cxx b/Source/cmDependsFortranLexer.cxx
index 1810806..d9c370f 100644
--- a/Source/cmDependsFortranLexer.cxx
+++ b/Source/cmDependsFortranLexer.cxx
@@ -1398,10 +1398,10 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
         else
                 {
-                        size_t num_to_read =
+                        size_t nuto_read =
                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
-                while ( num_to_read <= 0 )
+                while ( nuto_read <= 0 )
                         { /* Not enough room in the buffer - grow it. */
 
                         /* just a shorter name for the current buffer */
@@ -1433,17 +1433,17 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
                         yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
 
-                        num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+                        nuto_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
                                                 number_to_move - 1;
 
                         }
 
-                if ( num_to_read > YY_READ_BUF_SIZE )
-                        num_to_read = YY_READ_BUF_SIZE;
+                if ( nuto_read > YY_READ_BUF_SIZE )
+                        nuto_read = YY_READ_BUF_SIZE;
 
                 /* Read in more data. */
                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-                        yyg->yy_n_chars, num_to_read );
+                        yyg->yy_n_chars, nuto_read );
 
                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
                 }
@@ -1885,7 +1885,7 @@ void cmDependsFortran_yypop_buffer_state (yyscan_t yyscanner)
  */
 static void cmDependsFortran_yyensure_buffer_stack (yyscan_t yyscanner)
 {
-        int num_to_alloc;
+        int nuto_alloc;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
         if (!yyg->yy_buffer_stack) {
@@ -1894,14 +1894,15 @@ static void cmDependsFortran_yyensure_buffer_stack (yyscan_t yyscanner)
                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
                  * immediate realloc on the next call.
          */
-                num_to_alloc = 1;
+                nuto_alloc = 1;
                 yyg->yy_buffer_stack = (struct yy_buffer_state**)cmDependsFortran_yyalloc
-                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                                (nuto_alloc * sizeof(struct yy_buffer_state*)
                                                                 , yyscanner);
-
-                memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-
-                yyg->yy_buffer_stack_max = num_to_alloc;
+                
+                memset(yyg->yy_buffer_stack, 0, 
+                       nuto_alloc * sizeof(struct yy_buffer_state*));
+                                
+                yyg->yy_buffer_stack_max = nuto_alloc;
                 yyg->yy_buffer_stack_top = 0;
                 return;
         }
@@ -1911,15 +1912,15 @@ static void cmDependsFortran_yyensure_buffer_stack (yyscan_t yyscanner)
                 /* Increase the buffer to prepare for a possible push. */
                 int grow_size = 8 /* arbitrary grow size */;
 
-                num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
+                nuto_alloc = yyg->yy_buffer_stack_max + grow_size;
                 yyg->yy_buffer_stack = (struct yy_buffer_state**)cmDependsFortran_yyrealloc
                                                                 (yyg->yy_buffer_stack,
-                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                                nuto_alloc * sizeof(struct yy_buffer_state*)
                                                                 , yyscanner);
 
                 /* zero only the new slots.*/
                 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
-                yyg->yy_buffer_stack_max = num_to_alloc;
+                yyg->yy_buffer_stack_max = nuto_alloc;
         }
 }
 
diff --git a/Source/cmDependsJavaLexer.cxx b/Source/cmDependsJavaLexer.cxx
index ce20d3b..bee9e24 100644
--- a/Source/cmDependsJavaLexer.cxx
+++ b/Source/cmDependsJavaLexer.cxx
@@ -1672,10 +1672,10 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
   else
     {
-      size_t num_to_read =
+      size_t nuto_read =
       YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
-    while ( num_to_read <= 0 )
+    while ( nuto_read <= 0 )
       { /* Not enough room in the buffer - grow it. */
 
       /* just a shorter name for the current buffer */
@@ -1707,17 +1707,17 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
       yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
 
-      num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+      nuto_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
             number_to_move - 1;
 
       }
 
-    if ( num_to_read > YY_READ_BUF_SIZE )
-      num_to_read = YY_READ_BUF_SIZE;
+    if ( nuto_read > YY_READ_BUF_SIZE )
+      nuto_read = YY_READ_BUF_SIZE;
 
     /* Read in more data. */
     YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-      yyg->yy_n_chars, num_to_read );
+      yyg->yy_n_chars, nuto_read );
 
     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
     }
@@ -2118,7 +2118,7 @@ void cmDependsJava_yypop_buffer_state (yyscan_t yyscanner)
  */
 static void cmDependsJava_yyensure_buffer_stack (yyscan_t yyscanner)
 {
-  int num_to_alloc;
+  int nuto_alloc;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
   if (!yyg->yy_buffer_stack) {
@@ -2127,14 +2127,14 @@ static void cmDependsJava_yyensure_buffer_stack (yyscan_t yyscanner)
      * scanner will even need a stack. We use 2 instead of 1 to avoid an
      * immediate realloc on the next call.
          */
-    num_to_alloc = 1;
+    nuto_alloc = 1;
     yyg->yy_buffer_stack = (struct yy_buffer_state**)cmDependsJava_yyalloc
-                (num_to_alloc * sizeof(struct yy_buffer_state*)
+                (nuto_alloc * sizeof(struct yy_buffer_state*)
                 , yyscanner);
     
-    memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+    memset(yyg->yy_buffer_stack, 0, nuto_alloc * sizeof(struct yy_buffer_state*));
         
-    yyg->yy_buffer_stack_max = num_to_alloc;
+    yyg->yy_buffer_stack_max = nuto_alloc;
     yyg->yy_buffer_stack_top = 0;
     return;
   }
@@ -2144,15 +2144,15 @@ static void cmDependsJava_yyensure_buffer_stack (yyscan_t yyscanner)
     /* Increase the buffer to prepare for a possible push. */
     int grow_size = 8 /* arbitrary grow size */;
 
-    num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
+    nuto_alloc = yyg->yy_buffer_stack_max + grow_size;
     yyg->yy_buffer_stack = (struct yy_buffer_state**)cmDependsJava_yyrealloc
                 (yyg->yy_buffer_stack,
-                num_to_alloc * sizeof(struct yy_buffer_state*)
+                nuto_alloc * sizeof(struct yy_buffer_state*)
                 , yyscanner);
 
     /* zero only the new slots.*/
     memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
-    yyg->yy_buffer_stack_max = num_to_alloc;
+    yyg->yy_buffer_stack_max = nuto_alloc;
   }
 }
 
diff --git a/Source/cmDynamicLoader.cxx b/Source/cmDynamicLoader.cxx
index 8c80188..1a05060 100644
--- a/Source/cmDynamicLoader.cxx
+++ b/Source/cmDynamicLoader.cxx
@@ -36,7 +36,7 @@ public:
   static cmDynamicLoaderCache* GetInstance();
 
 private:
-  std::map<cmStdString, cmLibHandle> m_CacheMap;
+  std::map<cmStdString, cmLibHandle> CacheMap;
   static cmDynamicLoaderCache* Instance;
 };
 
@@ -53,13 +53,13 @@ void cmDynamicLoaderCache::CacheFile(const char* path, const cmLibHandle& p)
     {
     this->FlushCache(path);
     }
-  this->m_CacheMap[path] = p;
+  this->CacheMap[path] = p;
 }
 
 bool cmDynamicLoaderCache::GetCacheFile(const char* path, cmLibHandle& p)
 {
-  std::map<cmStdString, cmLibHandle>::iterator it = m_CacheMap.find(path);
-  if ( it != m_CacheMap.end() )
+  std::map<cmStdString, cmLibHandle>::iterator it = this->CacheMap.find(path);
+  if ( it != this->CacheMap.end() )
     {
     p = it->second;
     return true;
@@ -69,12 +69,12 @@ bool cmDynamicLoaderCache::GetCacheFile(const char* path, cmLibHandle& p)
 
 bool cmDynamicLoaderCache::FlushCache(const char* path)
 {
-  std::map<cmStdString, cmLibHandle>::iterator it = m_CacheMap.find(path);
+  std::map<cmStdString, cmLibHandle>::iterator it = this->CacheMap.find(path);
   bool ret = false;
-  if ( it != m_CacheMap.end() )
+  if ( it != this->CacheMap.end() )
     {
     cmDynamicLoader::CloseLibrary(it->second);
-    m_CacheMap.erase(it);
+    this->CacheMap.erase(it);
     ret = true;
     }
   return ret;
@@ -82,8 +82,8 @@ bool cmDynamicLoaderCache::FlushCache(const char* path)
 
 void cmDynamicLoaderCache::FlushCache()
 {
-  for ( std::map<cmStdString, cmLibHandle>::iterator it = m_CacheMap.begin();
-        it != m_CacheMap.end(); it++ )
+  for ( std::map<cmStdString, cmLibHandle>::iterator it = this->CacheMap.begin();
+        it != this->CacheMap.end(); it++ )
     {
     cmDynamicLoader::CloseLibrary(it->second);
     }
diff --git a/Source/cmEnableLanguageCommand.cxx b/Source/cmEnableLanguageCommand.cxx
index 8e1845e..2aa586e 100644
--- a/Source/cmEnableLanguageCommand.cxx
+++ b/Source/cmEnableLanguageCommand.cxx
@@ -24,7 +24,7 @@ bool cmEnableLanguageCommand::InitialPass(std::vector<std::string> const& args)
     this->SetError("ENABLE_LANGUAGE called with incorrect number of arguments");
     return false;
     } 
-  m_Makefile->EnableLanguage(args);
+  this->Makefile->EnableLanguage(args);
   return true;
 }
 
diff --git a/Source/cmEnableTestingCommand.cxx b/Source/cmEnableTestingCommand.cxx
index ce0b69a..3d94ba8 100644
--- a/Source/cmEnableTestingCommand.cxx
+++ b/Source/cmEnableTestingCommand.cxx
@@ -21,6 +21,6 @@
 // been defined
 bool cmEnableTestingCommand::InitialPass(std::vector<std::string> const&)
 {
-  m_Makefile->AddDefinition("CMAKE_TESTING_ENABLED","1");
+  this->Makefile->AddDefinition("CMAKE_TESTING_ENABLED","1");
   return true;
 }
diff --git a/Source/cmEndIfCommand.cxx b/Source/cmEndIfCommand.cxx
index 6bfad52..a16403e 100644
--- a/Source/cmEndIfCommand.cxx
+++ b/Source/cmEndIfCommand.cxx
@@ -19,7 +19,7 @@
 bool cmEndIfCommand::InitialPass(std::vector<std::string> const&)
 {
   const char* versionValue
-    = m_Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION");
+    = this->Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION");
   if (!versionValue || (atof(versionValue) <= 1.4))
     {
     return true;
diff --git a/Source/cmExecProgramCommand.cxx b/Source/cmExecProgramCommand.cxx
index 10de71b..b201b72 100644
--- a/Source/cmExecProgramCommand.cxx
+++ b/Source/cmExecProgramCommand.cxx
@@ -133,14 +133,14 @@ bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& args)
       }
     
     std::string coutput = std::string(output, first, last-first+1);
-    m_Makefile->AddDefinition(output_variable.c_str(), coutput.c_str());
+    this->Makefile->AddDefinition(output_variable.c_str(), coutput.c_str());
     }
 
   if ( return_variable.size() > 0 )
     {
     char buffer[100];
     sprintf(buffer, "%d", retVal);
-    m_Makefile->AddDefinition(return_variable.c_str(), buffer);
+    this->Makefile->AddDefinition(return_variable.c_str(), buffer);
     }
   
   return true;
diff --git a/Source/cmExecuteProcessCommand.cxx b/Source/cmExecuteProcessCommand.cxx
index 54cd7ed..2dfce3b 100644
--- a/Source/cmExecuteProcessCommand.cxx
+++ b/Source/cmExecuteProcessCommand.cxx
@@ -288,11 +288,11 @@ bool cmExecuteProcessCommand::InitialPass(std::vector<std::string> const& args)
   // Store the output obtained.
   if(!output_variable.empty())
     {
-    m_Makefile->AddDefinition(output_variable.c_str(), &*tempOutput.begin());
+    this->Makefile->AddDefinition(output_variable.c_str(), &*tempOutput.begin());
     }
   if(!merge_output && !error_variable.empty())
     {
-    m_Makefile->AddDefinition(error_variable.c_str(), &*tempError.begin());
+    this->Makefile->AddDefinition(error_variable.c_str(), &*tempError.begin());
     }
 
   // Store the result of running the process.
@@ -305,19 +305,19 @@ bool cmExecuteProcessCommand::InitialPass(std::vector<std::string> const& args)
         int v = cmsysProcess_GetExitValue(cp);
         char buf[100];
         sprintf(buf, "%d", v);
-        m_Makefile->AddDefinition(result_variable.c_str(), buf);
+        this->Makefile->AddDefinition(result_variable.c_str(), buf);
         }
         break;
       case cmsysProcess_State_Exception:
-        m_Makefile->AddDefinition(result_variable.c_str(),
+        this->Makefile->AddDefinition(result_variable.c_str(),
                                   cmsysProcess_GetExceptionString(cp));
         break;
       case cmsysProcess_State_Error:
-        m_Makefile->AddDefinition(result_variable.c_str(),
+        this->Makefile->AddDefinition(result_variable.c_str(),
                                   cmsysProcess_GetErrorString(cp));
         break;
       case cmsysProcess_State_Expired:
-        m_Makefile->AddDefinition(result_variable.c_str(),
+        this->Makefile->AddDefinition(result_variable.c_str(),
                                   "Process terminated due to timeout");
         break;
       }
diff --git a/Source/cmExportLibraryDependencies.cxx b/Source/cmExportLibraryDependencies.cxx
index de55cc4..3f39920 100644
--- a/Source/cmExportLibraryDependencies.cxx
+++ b/Source/cmExportLibraryDependencies.cxx
@@ -38,7 +38,7 @@ bool cmExportLibraryDependenciesCommand::InitialPass(std::vector<std::string> co
   // store the arguments for the final pass
   // also expand any CMake variables
 
-  m_Args = args;
+  this->Args = args;
   return true;
 }
 
@@ -46,11 +46,11 @@ bool cmExportLibraryDependenciesCommand::InitialPass(std::vector<std::string> co
 void cmExportLibraryDependenciesCommand::FinalPass()
 {
   // Create a full path filename for output
-  std::string fname = m_Args[0];
+  std::string fname = this->Args[0];
   bool append = false;
-  if(m_Args.size() > 1)
+  if(this->Args.size() > 1)
     {
-    if(m_Args[1] == "APPEND")
+    if(this->Args[1] == "APPEND")
       {
       append = true;
       }
@@ -79,7 +79,7 @@ void cmExportLibraryDependenciesCommand::FinalPass()
     cmSystemTools::ReportLastSystemError("");
     return;
     }
-  cmake* cm = m_Makefile->GetCMakeInstance();
+  cmake* cm = this->Makefile->GetCMakeInstance();
   cmGlobalGenerator* global = cm->GetGlobalGenerator();
   std::vector<cmLocalGenerator *> locals;
   global->GetLocalGenerators(locals);
@@ -99,7 +99,7 @@ void cmExportLibraryDependenciesCommand::FinalPass()
         {
         libDepName = l->first;
         libDepName += "_LIB_DEPENDS";
-        const char* def = m_Makefile->GetDefinition(libDepName.c_str());
+        const char* def = this->Makefile->GetDefinition(libDepName.c_str());
         if(def)
           {
           fout << "SET(" << libDepName << " \"" << def << "\")\n";
@@ -110,7 +110,7 @@ void cmExportLibraryDependenciesCommand::FinalPass()
             {
             libDepName = *d;
             libDepName += "_LINK_TYPE";
-            defType = m_Makefile->GetDefinition(libDepName.c_str());
+            defType = this->Makefile->GetDefinition(libDepName.c_str());
             libDepName = cmSystemTools::EscapeSpaces(libDepName.c_str());
             if(defType)
               {
diff --git a/Source/cmExportLibraryDependencies.h b/Source/cmExportLibraryDependencies.h
index 51c80b7..dc46fc8 100644
--- a/Source/cmExportLibraryDependencies.h
+++ b/Source/cmExportLibraryDependencies.h
@@ -79,7 +79,7 @@ public:
   cmTypeMacro(cmExportLibraryDependenciesCommand, cmCommand);
 
 private:
-  std::vector<std::string> m_Args;
+  std::vector<std::string> Args;
 };
 
 
diff --git a/Source/cmExprLexer.cxx b/Source/cmExprLexer.cxx
index a039ccc..7a025f2 100644
--- a/Source/cmExprLexer.cxx
+++ b/Source/cmExprLexer.cxx
@@ -1059,10 +1059,10 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
   else
     {
-      size_t num_to_read =
+      size_t nuto_read =
       YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
-    while ( num_to_read <= 0 )
+    while ( nuto_read <= 0 )
       { /* Not enough room in the buffer - grow it. */
 
       /* just a shorter name for the current buffer */
@@ -1094,17 +1094,17 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 
       yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
 
-      num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+      nuto_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
             number_to_move - 1;
 
       }
 
-    if ( num_to_read > YY_READ_BUF_SIZE )
-      num_to_read = YY_READ_BUF_SIZE;
+    if ( nuto_read > YY_READ_BUF_SIZE )
+      nuto_read = YY_READ_BUF_SIZE;
 
     /* Read in more data. */
     YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-      yyg->yy_n_chars, num_to_read );
+      yyg->yy_n_chars, nuto_read );
 
     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
     }
@@ -1505,7 +1505,7 @@ void cmExpr_yypop_buffer_state (yyscan_t yyscanner)
  */
 static void cmExpr_yyensure_buffer_stack (yyscan_t yyscanner)
 {
-  int num_to_alloc;
+  int nuto_alloc;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
   if (!yyg->yy_buffer_stack) {
@@ -1514,14 +1514,14 @@ static void cmExpr_yyensure_buffer_stack (yyscan_t yyscanner)
      * scanner will even need a stack. We use 2 instead of 1 to avoid an
      * immediate realloc on the next call.
          */
-    num_to_alloc = 1;
+    nuto_alloc = 1;
     yyg->yy_buffer_stack = (struct yy_buffer_state**)cmExpr_yyalloc
-                (num_to_alloc * sizeof(struct yy_buffer_state*)
+                (nuto_alloc * sizeof(struct yy_buffer_state*)
                 , yyscanner);
     
-    memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+    memset(yyg->yy_buffer_stack, 0, nuto_alloc * sizeof(struct yy_buffer_state*));
         
-    yyg->yy_buffer_stack_max = num_to_alloc;
+    yyg->yy_buffer_stack_max = nuto_alloc;
     yyg->yy_buffer_stack_top = 0;
     return;
   }
@@ -1531,15 +1531,15 @@ static void cmExpr_yyensure_buffer_stack (yyscan_t yyscanner)
     /* Increase the buffer to prepare for a possible push. */
     int grow_size = 8 /* arbitrary grow size */;
 
-    num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
+    nuto_alloc = yyg->yy_buffer_stack_max + grow_size;
     yyg->yy_buffer_stack = (struct yy_buffer_state**)cmExpr_yyrealloc
                 (yyg->yy_buffer_stack,
-                num_to_alloc * sizeof(struct yy_buffer_state*)
+                nuto_alloc * sizeof(struct yy_buffer_state*)
                 , yyscanner);
 
     /* zero only the new slots.*/
     memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
-    yyg->yy_buffer_stack_max = num_to_alloc;
+    yyg->yy_buffer_stack_max = nuto_alloc;
   }
 }
 
diff --git a/Source/cmExprParserHelper.cxx b/Source/cmExprParserHelper.cxx
index 2a70bb6..1b6852d 100644
--- a/Source/cmExprParserHelper.cxx
+++ b/Source/cmExprParserHelper.cxx
@@ -25,8 +25,8 @@ int cmExpr_yyparse( yyscan_t yyscanner );
 //
 cmExprParserHelper::cmExprParserHelper()
 {
-  m_FileLine = -1;
-  m_FileName = 0;
+  this->FileLine = -1;
+  this->FileName = 0;
 }
 
 
@@ -37,8 +37,8 @@ cmExprParserHelper::~cmExprParserHelper()
 
 void cmExprParserHelper::SetLineFile(long line, const char* file)
 {
-  m_FileLine = line;
-  m_FileName = file;
+  this->FileLine = line;
+  this->FileName = file;
 }
 
 int cmExprParserHelper::ParseString(const char* str, int verb)
@@ -54,7 +54,7 @@ int cmExprParserHelper::ParseString(const char* str, int verb)
   this->InputBufferPos = 0;
   this->CurrentLine = 0;
   
-  m_Result = 0;
+  this->Result = 0;
 
   yyscan_t yyscanner;
   cmExpr_yylex_init(&yyscanner);
@@ -72,7 +72,7 @@ int cmExprParserHelper::ParseString(const char* str, int verb)
 
   if ( Verbose )
     {
-    std::cerr << "Expanding [" << str << "] produced: [" << m_Result << "]" << std::endl;
+    std::cerr << "Expanding [" << str << "] produced: [" << this->Result << "]" << std::endl;
     }
   return 1;
 }
@@ -122,12 +122,12 @@ void cmExprParserHelper::Error(const char* str)
     }
   std::cerr << "]" << std::endl;
   */
-  m_Error = ostr.str();
+  this->ErrorString = ostr.str();
 }
 
 void cmExprParserHelper::SetResult(int value)
 {
-  m_Result = value;
+  this->Result = value;
 }
 
 
diff --git a/Source/cmExprParserHelper.h b/Source/cmExprParserHelper.h
index 5fd2c3d..2b95cda 100644
--- a/Source/cmExprParserHelper.h
+++ b/Source/cmExprParserHelper.h
@@ -49,11 +49,11 @@ public:
 
   void SetResult(int value);
 
-  int GetResult() { return m_Result; }
+  int GetResult() { return this->Result; }
 
   void SetLineFile(long line, const char* file);
 
-  const char* GetError() { return m_Error.c_str(); }
+  const char* GetError() { return this->ErrorString.c_str(); }
 
 private:
   cmStdString::size_type InputBufferPos;
@@ -67,10 +67,10 @@ private:
 
   void CleanupParser();
 
-  int m_Result;
-  const char* m_FileName;
-  long m_FileLine;
-  std::string m_Error;
+  int Result;
+  const char* FileName;
+  long FileLine;
+  std::string ErrorString;
 };
 
 #endif
diff --git a/Source/cmFLTKWrapUICommand.cxx b/Source/cmFLTKWrapUICommand.cxx
index ed8f70f..1252fe6 100644
--- a/Source/cmFLTKWrapUICommand.cxx
+++ b/Source/cmFLTKWrapUICommand.cxx
@@ -28,27 +28,27 @@ bool cmFLTKWrapUICommand::InitialPass(std::vector<std::string> const& args)
     }
 
   // what is the current source dir
-  std::string cdir = m_Makefile->GetCurrentDirectory();
+  std::string cdir = this->Makefile->GetCurrentDirectory();
   const char* fluid_exe =
-    m_Makefile->GetRequiredDefinition("FLTK_FLUID_EXECUTABLE");
+    this->Makefile->GetRequiredDefinition("FLTK_FLUID_EXECUTABLE");
 
   // get parameter for the command
-  m_Target              = args[0];  // Target that will use the generated files
+  this->Target = args[0];  // Target that will use the generated files
 
   std::vector<std::string> newArgs;
-  m_Makefile->ExpandSourceListArguments(args,newArgs, 1);
+  this->Makefile->ExpandSourceListArguments(args,newArgs, 1);
   
   // get the list of GUI files from which .cxx and .h will be generated 
-  std::string outputDirectory = m_Makefile->GetCurrentOutputDirectory();
+  std::string outputDirectory = this->Makefile->GetCurrentOutputDirectory();
 
   // Some of the generated files are *.h so the directory "GUI" 
   // where they are created have to be added to the include path
-  m_Makefile->AddIncludeDirectory( outputDirectory.c_str() );
+  this->Makefile->AddIncludeDirectory( outputDirectory.c_str() );
 
   for(std::vector<std::string>::iterator i = (newArgs.begin() + 1); 
       i != newArgs.end(); i++)
     {
-    cmSourceFile *curr = m_Makefile->GetSource(i->c_str());
+    cmSourceFile *curr = this->Makefile->GetSource(i->c_str());
     // if we should use the source GUI 
     // to generate .cxx and .h files
     if (!curr || !curr->GetPropertyAsBool("WRAP_EXCLUDE"))
@@ -82,24 +82,24 @@ bool cmFLTKWrapUICommand::InitialPass(std::vector<std::string> const& args)
       const char* no_main_dependency = 0;
       const char* no_comment = 0;
       const char* no_working_dir = 0;
-      m_Makefile->AddCustomCommandToOutput(cxxres.c_str(),
+      this->Makefile->AddCustomCommandToOutput(cxxres.c_str(),
                                            depends, no_main_dependency,
                                            commandLines, no_comment,
                                            no_working_dir);
-      m_Makefile->AddCustomCommandToOutput(hname.c_str(),
+      this->Makefile->AddCustomCommandToOutput(hname.c_str(),
                                            depends, no_main_dependency,
                                            commandLines, no_comment,
                                            no_working_dir);
 
-      cmSourceFile *sf = m_Makefile->GetSource(cxxres.c_str());
+      cmSourceFile *sf = this->Makefile->GetSource(cxxres.c_str());
       sf->GetDepends().push_back(hname);
       sf->GetDepends().push_back(origname);
-      m_GeneratedSourcesClasses.push_back(sf);
+      this->GeneratedSourcesClasses.push_back(sf);
       }
     }
 
   // create the variable with the list of sources in it
-  size_t lastHeadersClass = m_GeneratedSourcesClasses.size();
+  size_t lastHeadersClass = this->GeneratedSourcesClasses.size();
   std::string sourceListValue;
   for(size_t classNum = 0; classNum < lastHeadersClass; classNum++)
     {
@@ -107,11 +107,11 @@ bool cmFLTKWrapUICommand::InitialPass(std::vector<std::string> const& args)
       {
       sourceListValue += ";";
       }
-    sourceListValue += m_GeneratedSourcesClasses[classNum]->GetFullPath();
+    sourceListValue += this->GeneratedSourcesClasses[classNum]->GetFullPath();
     }
-  std::string varName = m_Target;
+  std::string varName = this->Target;
   varName += "_FLTK_UI_SRCS";
-  m_Makefile->AddDefinition(varName.c_str(), sourceListValue.c_str());
+  this->Makefile->AddDefinition(varName.c_str(), sourceListValue.c_str());
   
   return true;
 }
@@ -122,12 +122,12 @@ void cmFLTKWrapUICommand::FinalPass()
   // didn't support that, so check and see if they added the files in and if
   // they didn;t then print a warning and add then anyhow
   std::vector<std::string> srcs = 
-    m_Makefile->GetTargets()[m_Target].GetSourceLists();
+    this->Makefile->GetTargets()[this->Target].GetSourceLists();
   bool found = false;
   for (unsigned int i = 0; i < srcs.size(); ++i)
     {
     if (srcs[i] == 
-        m_GeneratedSourcesClasses[0]->GetFullPath())
+        this->GeneratedSourcesClasses[0]->GetFullPath())
       {
       found = true;
       break;
@@ -137,16 +137,16 @@ void cmFLTKWrapUICommand::FinalPass()
     {
     std::string msg = "In CMake 2.2 the FLTK_WRAP_UI command sets a variable to the list of source files that should be added to your executable or library. It appears that you have not added these source files to your target. You should change your CMakeLists.txt file to directly add the generated files to the target. For example FTLK_WRAP_UI(foo src1 src2 src3) will create a variable named foo_FLTK_UI_SRCS that contains the list of sources to add to your target when you call ADD_LIBRARY or ADD_EXECUTABLE. For now CMake 2.2 will add the sources to your target for you as was done in CMake 2.0 and earlier. In the future this may become an error. ";
     msg += "The problem was found while processing the source directory: ";
-    msg += m_Makefile->GetStartDirectory();
+    msg += this->Makefile->GetStartDirectory();
     cmSystemTools::Message(msg.c_str(),"Warning");
     // first we add the rules for all the .fl to .h and .cxx files
-    size_t lastHeadersClass = m_GeneratedSourcesClasses.size();
+    size_t lastHeadersClass = this->GeneratedSourcesClasses.size();
     
     // Generate code for all the .fl files
     for(size_t classNum = 0; classNum < lastHeadersClass; classNum++)
       {
-      m_Makefile->GetTargets()[m_Target].GetSourceFiles().push_back( 
-                                                                    m_GeneratedSourcesClasses[classNum]);
+      this->Makefile->GetTargets()[this->Target].GetSourceFiles().push_back( 
+                                                                    this->GeneratedSourcesClasses[classNum]);
       }
     }
 }
diff --git a/Source/cmFLTKWrapUICommand.h b/Source/cmFLTKWrapUICommand.h
index eb28ace..e88e1b9 100644
--- a/Source/cmFLTKWrapUICommand.h
+++ b/Source/cmFLTKWrapUICommand.h
@@ -83,13 +83,13 @@ private:
   /**
    * List of produced files.
    */
-  std::vector<cmSourceFile *> m_GeneratedSourcesClasses;
+  std::vector<cmSourceFile *> GeneratedSourcesClasses;
 
   /**
    * List of Fluid files that provide the source 
    * generating .cxx and .h files
    */
-  std::string m_Target;
+  std::string Target;
 };
 
 
diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx
index 6895f84..fb75d05 100644
--- a/Source/cmFileCommand.cxx
+++ b/Source/cmFileCommand.cxx
@@ -93,7 +93,7 @@ bool cmFileCommand::HandleWriteCommand(std::vector<std::string> const& args,
   std::string fileName = *i;
   if ( !cmsys::SystemTools::FileIsFullPath(i->c_str()) )
     {
-    fileName = m_Makefile->GetCurrentDirectory();
+    fileName = this->Makefile->GetCurrentDirectory();
     fileName += "/" + *i;
     }
 
@@ -143,7 +143,7 @@ bool cmFileCommand::HandleWriteCommand(std::vector<std::string> const& args,
   file << message;
   file.close();
   cmSystemTools::SetPermissions(fileName.c_str(), mode);
-  m_Makefile->AddWrittenFile(fileName.c_str());
+  this->Makefile->AddWrittenFile(fileName.c_str());
   return true;
 }
 
@@ -159,7 +159,7 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
   std::string fileName = args[1];
   if ( !cmsys::SystemTools::FileIsFullPath(args[1].c_str()) )
     {
-    fileName = m_Makefile->GetCurrentDirectory();
+    fileName = this->Makefile->GetCurrentDirectory();
     fileName += "/" + args[1];
     }
 
@@ -185,7 +185,7 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
       output += "\n";
       }
     }
-  m_Makefile->AddDefinition(variable.c_str(), output.c_str());
+  this->Makefile->AddDefinition(variable.c_str(), output.c_str());
   return true;
 }
 
@@ -213,7 +213,7 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
     {
     if ( !cmsys::SystemTools::FileIsFullPath(i->c_str()) )
       {
-      std::string expr = m_Makefile->GetCurrentDirectory();
+      std::string expr = this->Makefile->GetCurrentDirectory();
       // Handle script mode
       if ( expr.size() > 0 )
         {
@@ -241,7 +241,7 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
       first = false;
       }
     }
-  m_Makefile->AddDefinition(variable.c_str(), output.c_str());
+  this->Makefile->AddDefinition(variable.c_str(), output.c_str());
   return true;
 }
 
@@ -265,7 +265,7 @@ bool cmFileCommand::HandleMakeDirectoryCommand(
     const std::string* cdir = &(*i);
     if ( !cmsys::SystemTools::FileIsFullPath(i->c_str()) )
       {
-      expr = m_Makefile->GetCurrentDirectory();
+      expr = this->Makefile->GetCurrentDirectory();
       expr += "/" + *i;
       cdir = &expr;
       }
@@ -292,7 +292,7 @@ bool cmFileCommand::HandleInstallCommand(
   std::string rename = "";
   std::string destination = "";
   std::string stype = "FILES";
-  const char* build_type = m_Makefile->GetDefinition("BUILD_TYPE");
+  const char* build_type = this->Makefile->GetDefinition("BUILD_TYPE");
   if ( build_type && strcmp(build_type, ".") == 0 )
     {
     build_type = 0;
@@ -621,7 +621,7 @@ bool cmFileCommand::HandleInstallCommand(
 
   // Get the current manifest.
   const char* manifest_files = 
-    m_Makefile->GetDefinition("CMAKE_INSTALL_MANIFEST_FILES");
+    this->Makefile->GetDefinition("CMAKE_INSTALL_MANIFEST_FILES");
   std::string smanifest_files;
   if ( manifest_files )
     {
@@ -755,7 +755,7 @@ bool cmFileCommand::HandleInstallCommand(
         // We will install this file.  Display the information.
         message = "Installing ";
         message += toFile.c_str();
-        m_Makefile->DisplayStatus(message.c_str(), -1);
+        this->Makefile->DisplayStatus(message.c_str(), -1);
 
         // If no permissions were already given use the permissions of
         // the file being copied.
@@ -830,7 +830,7 @@ bool cmFileCommand::HandleInstallCommand(
     }
 
   // Save the updated install manifest.
-  m_Makefile->AddDefinition("CMAKE_INSTALL_MANIFEST_FILES",
+  this->Makefile->AddDefinition("CMAKE_INSTALL_MANIFEST_FILES",
                             smanifest_files.c_str());
 
   return true;
@@ -864,7 +864,7 @@ bool cmFileCommand::HandleRelativePathCommand(
     }
 
   std::string res = cmSystemTools::RelativePath(directoryName.c_str(), fileName.c_str());
-  m_Makefile->AddDefinition(outVar.c_str(),
+  this->Makefile->AddDefinition(outVar.c_str(),
     res.c_str());
   return true;
 }
@@ -915,6 +915,6 @@ bool cmFileCommand::HandleSystemPathCommand(std::vector<std::string>
     value += *j;
     value += ";";
     }
-  m_Makefile->AddDefinition(var, value.c_str());
+  this->Makefile->AddDefinition(var, value.c_str());
   return true;
 }
diff --git a/Source/cmFileTimeComparison.cxx b/Source/cmFileTimeComparison.cxx
index 98a52d6..e0e3c86 100644
--- a/Source/cmFileTimeComparison.cxx
+++ b/Source/cmFileTimeComparison.cxx
@@ -106,19 +106,19 @@ bool cmFileTimeComparisonInternal::Stat(const char* fname,
 //----------------------------------------------------------------------------
 cmFileTimeComparison::cmFileTimeComparison()
 {
-  m_Internals = new cmFileTimeComparisonInternal;
+  this->Internals = new cmFileTimeComparisonInternal;
 }
 
 //----------------------------------------------------------------------------
 cmFileTimeComparison::~cmFileTimeComparison()
 {
-  delete m_Internals;
+  delete this->Internals;
 }
 
 //----------------------------------------------------------------------------
 bool cmFileTimeComparison::FileTimeCompare(const char* f1, const char* f2, int* result)
 {
-  return m_Internals->FileTimeCompare(f1, f2, result);
+  return this->Internals->FileTimeCompare(f1, f2, result);
 }
 
 //----------------------------------------------------------------------------
diff --git a/Source/cmFileTimeComparison.h b/Source/cmFileTimeComparison.h
index 2fc243f..5da97db 100644
--- a/Source/cmFileTimeComparison.h
+++ b/Source/cmFileTimeComparison.h
@@ -42,7 +42,7 @@ public:
 
 protected:
   
-  cmFileTimeComparisonInternal* m_Internals;
+  cmFileTimeComparisonInternal* Internals;
 };
 
 
diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx
index 396ee8a..841d8c7 100644
--- a/Source/cmFindBase.cxx
+++ b/Source/cmFindBase.cxx
@@ -297,7 +297,8 @@ void cmFindBase::AddCMakeVairables()
 { 
   if(this->SearchFrameworkFirst || this->SearchFrameworkOnly)
     { 
-    if(const char* path = m_Makefile->GetDefinition("CMAKE_FRAMEWORK_PATH"))
+    if(const char* path = 
+       this->Makefile->GetDefinition("CMAKE_FRAMEWORK_PATH"))
       {
       cmSystemTools::ExpandListArgument(path, this->SearchPaths);
       }
@@ -305,13 +306,14 @@ void cmFindBase::AddCMakeVairables()
   std::string var = "CMAKE_";
   var += this->CMakePathName;
   var += "_PATH";
-  if(const char* path = m_Makefile->GetDefinition(var.c_str()))
+  if(const char* path = this->Makefile->GetDefinition(var.c_str()))
     {
     cmSystemTools::ExpandListArgument(path, this->SearchPaths);
     } 
   if(this->SearchFrameworkLast)
     {
-    if(const char* path = m_Makefile->GetDefinition("CMAKE_FRAMEWORK_PATH"))
+    if(const char* path = 
+       this->Makefile->GetDefinition("CMAKE_FRAMEWORK_PATH"))
       {
       cmSystemTools::ExpandListArgument(path, this->SearchPaths);
       }
@@ -333,7 +335,7 @@ void cmFindBase::AddCMakeSystemVariables()
 {  
   if(this->SearchFrameworkFirst || this->SearchFrameworkOnly)
     { 
-    if(const char* path = m_Makefile->GetDefinition("CMAKE_SYSTEM_FRAMEWORK_PATH"))
+    if(const char* path = this->Makefile->GetDefinition("CMAKE_SYSTEM_FRAMEWORK_PATH"))
       {
       cmSystemTools::ExpandListArgument(path, this->SearchPaths);
       }
@@ -341,13 +343,13 @@ void cmFindBase::AddCMakeSystemVariables()
   std::string var = "CMAKE_SYSTEM_";
   var += this->CMakePathName;
   var += "_PATH";
-  if(const char* path = m_Makefile->GetDefinition(var.c_str()))
+  if(const char* path = this->Makefile->GetDefinition(var.c_str()))
     {
     cmSystemTools::ExpandListArgument(path, this->SearchPaths);
     }  
   if(this->SearchFrameworkLast)
     {
-    if(const char* path = m_Makefile->GetDefinition("CMAKE_SYSTEM_FRAMEWORK_PATH"))
+    if(const char* path = this->Makefile->GetDefinition("CMAKE_SYSTEM_FRAMEWORK_PATH"))
       {
       cmSystemTools::ExpandListArgument(path, this->SearchPaths);
       }
@@ -426,7 +428,7 @@ void cmFindBase::PrintFindStuff()
 bool cmFindBase::CheckForVariableInCache()
 {
   const char* cacheValue
-    = m_Makefile->GetDefinition(this->VariableName.c_str());
+    = this->Makefile->GetDefinition(this->VariableName.c_str());
   if(cacheValue && !cmSystemTools::IsNOTFOUND(cacheValue))
     {
     return true;
@@ -434,7 +436,7 @@ bool cmFindBase::CheckForVariableInCache()
   if(cacheValue)
     {
     cmCacheManager::CacheIterator it = 
-      m_Makefile->GetCacheManager()->GetCacheIterator(this->VariableName.c_str());
+      this->Makefile->GetCacheManager()->GetCacheIterator(this->VariableName.c_str());
     if(!it.IsAtEnd())
       {
       const char* hs = it.GetProperty("HELPSTRING");
diff --git a/Source/cmFindLibraryCommand.cxx b/Source/cmFindLibraryCommand.cxx
index 9cd77b3..7ddad5e 100644
--- a/Source/cmFindLibraryCommand.cxx
+++ b/Source/cmFindLibraryCommand.cxx
@@ -62,29 +62,29 @@ bool cmFindLibraryCommand::InitialPass(std::vector<std::string> const& argsIn)
     library = this->FindLibrary(i->c_str());
     if(library != "")
       {  
-      m_Makefile->AddCacheDefinition(this->VariableName.c_str(),
-                                     library.c_str(),
-                                     this->VariableDocumentation.c_str(),
-                                     cmCacheManager::FILEPATH);
+      this->Makefile->AddCacheDefinition(this->VariableName.c_str(),
+                                         library.c_str(),
+                                         this->VariableDocumentation.c_str(),
+                                         cmCacheManager::FILEPATH);
       return true;
       } 
     }
   std::string notfound = this->VariableName + "-NOTFOUND";
-  m_Makefile->AddCacheDefinition(this->VariableName.c_str(),
-                                 notfound.c_str(),
-                                 this->VariableDocumentation.c_str(),
-                                 cmCacheManager::FILEPATH);
+  this->Makefile->AddCacheDefinition(this->VariableName.c_str(),
+                                     notfound.c_str(),
+                                     this->VariableDocumentation.c_str(),
+                                     cmCacheManager::FILEPATH);
   return true;
 }
 
 
 void cmFindLibraryCommand::AddLib64Paths()
 {  
-  if(!m_Makefile->GetLocalGenerator()->GetGlobalGenerator()->GetLanguageEnabled("C"))
+  if(!this->Makefile->GetLocalGenerator()->GetGlobalGenerator()->GetLanguageEnabled("C"))
     {
     return;
     }
-  std::string voidsize = m_Makefile->GetRequiredDefinition("CMAKE_SIZEOF_VOID_P");
+  std::string voidsize = this->Makefile->GetRequiredDefinition("CMAKE_SIZEOF_VOID_P");
   int size = atoi(voidsize.c_str());
   std::vector<std::string> path64;
   if(size != 8)
@@ -131,7 +131,7 @@ std::string cmFindLibraryCommand::FindLibrary(const char* name)
 {
   bool supportFrameworks = false;
   bool onlyFrameworks = false;
-  std::string ff = m_Makefile->GetSafeDefinition("CMAKE_FIND_FRAMEWORK");
+  std::string ff = this->Makefile->GetSafeDefinition("CMAKE_FIND_FRAMEWORK");
   if(ff == "FIRST" || ff == "LAST")
     {
     supportFrameworks = true;
@@ -143,9 +143,9 @@ std::string cmFindLibraryCommand::FindLibrary(const char* name)
     }
   
   const char* prefixes_list =
-    m_Makefile->GetRequiredDefinition("CMAKE_FIND_LIBRARY_PREFIXES");
+    this->Makefile->GetRequiredDefinition("CMAKE_FIND_LIBRARY_PREFIXES");
   const char* suffixes_list =
-    m_Makefile->GetRequiredDefinition("CMAKE_FIND_LIBRARY_SUFFIXES");
+    this->Makefile->GetRequiredDefinition("CMAKE_FIND_LIBRARY_SUFFIXES");
   std::vector<std::string> prefixes;
   std::vector<std::string> suffixes;
   cmSystemTools::ExpandListArgument(prefixes_list, prefixes, true);
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index 15b6410..ef2777f 100644
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@@ -78,7 +78,7 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
         while (++i < args.size() && args[i] != "QUIET")
           {
           std::string req_var = Name + "_FIND_REQUIRED_" + args[i];
-          m_Makefile->AddDefinition(req_var.c_str(), "1");
+          this->Makefile->AddDefinition(req_var.c_str(), "1");
           }
         }
       else
@@ -118,7 +118,7 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
   if(!(upperDir == this->Variable))
     {
     const char* versionValue =
-      m_Makefile->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY");
+      this->Makefile->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY");
     if(atof(versionValue) < 1.7)
       {
       needCompatibility = true;
@@ -126,16 +126,16 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
     }
 
   // Try to find the config file.
-  const char* def = m_Makefile->GetDefinition(this->Variable.c_str());
+  const char* def = this->Makefile->GetDefinition(this->Variable.c_str());
   if(needCompatibility && cmSystemTools::IsOff(def))
     {
     // Use the setting of the old name of the variable to provide the
     // value of the new.
-    const char* oldDef = m_Makefile->GetDefinition(upperDir.c_str());
+    const char* oldDef = this->Makefile->GetDefinition(upperDir.c_str());
     if(!cmSystemTools::IsOff(oldDef))
       {
-      m_Makefile->AddDefinition(this->Variable.c_str(), oldDef);
-      def = m_Makefile->GetDefinition(this->Variable.c_str());
+      this->Makefile->AddDefinition(this->Variable.c_str(), oldDef);
+      def = this->Makefile->GetDefinition(this->Variable.c_str());
       }
     }
   if(cmSystemTools::IsOff(def))
@@ -149,7 +149,7 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
   // If the config file was found, load it.
   bool result = true;
   bool found = false;
-  def = m_Makefile->GetDefinition(this->Variable.c_str());
+  def = this->Makefile->GetDefinition(this->Variable.c_str());
   if(!cmSystemTools::IsOff(def))
     {
     std::string f = def;
@@ -196,16 +196,16 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
   // Set a variable marking whether the package was found.
   std::string foundVar = this->Name;
   foundVar += "_FOUND";
-  m_Makefile->AddDefinition(foundVar.c_str(), found? "1":"0");
+  this->Makefile->AddDefinition(foundVar.c_str(), found? "1":"0");
 
   if(needCompatibility)
     {
     // Listfiles will be looking for the capitalized version of the
     // name.  Provide it.
-    m_Makefile->AddDefinition(upperDir.c_str(),
-                              m_Makefile->GetDefinition(this->Variable.c_str()));
-    m_Makefile->AddDefinition(upperFound.c_str(),
-                              m_Makefile->GetDefinition(foundVar.c_str()));
+    this->Makefile->AddDefinition(upperDir.c_str(),
+                              this->Makefile->GetDefinition(this->Variable.c_str()));
+    this->Makefile->AddDefinition(upperFound.c_str(),
+                              this->Makefile->GetDefinition(foundVar.c_str()));
     }
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
@@ -215,11 +215,11 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
       {
       // Listfiles may use the capitalized version of the name.
       // Remove any previously added watch.
-      m_Makefile->GetVariableWatch()->RemoveWatch(
+      this->Makefile->GetVariableWatch()->RemoveWatch(
         upperDir.c_str(),
         cmFindPackageNeedBackwardsCompatibility
         );
-      m_Makefile->GetVariableWatch()->RemoveWatch(
+      this->Makefile->GetVariableWatch()->RemoveWatch(
         upperFound.c_str(),
         cmFindPackageNeedBackwardsCompatibility
         );
@@ -228,11 +228,11 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
       {
       // Listfiles should not be using the capitalized version of the
       // name.  Add a watch to warn the user.
-      m_Makefile->GetVariableWatch()->AddWatch(
+      this->Makefile->GetVariableWatch()->AddWatch(
         upperDir.c_str(),
         cmFindPackageNeedBackwardsCompatibility
         );
-      m_Makefile->GetVariableWatch()->AddWatch(
+      this->Makefile->GetVariableWatch()->AddWatch(
         upperFound.c_str(),
         cmFindPackageNeedBackwardsCompatibility
         );
@@ -249,7 +249,7 @@ bool cmFindPackageCommand::FindModule(bool& found, bool quiet, bool required)
   std::string module = "Find";
   module += this->Name;
   module += ".cmake";
-  std::string mfile = m_Makefile->GetModulesFile(module.c_str());
+  std::string mfile = this->Makefile->GetModulesFile(module.c_str());
   if ( mfile.size() )
     {
     if(quiet)
@@ -258,7 +258,7 @@ bool cmFindPackageCommand::FindModule(bool& found, bool quiet, bool required)
       // quietly.
       std::string quietly = this->Name;
       quietly += "_FIND_QUIETLY";
-      m_Makefile->AddDefinition(quietly.c_str(), "1");
+      this->Makefile->AddDefinition(quietly.c_str(), "1");
       }
 
     if(required)
@@ -267,7 +267,7 @@ bool cmFindPackageCommand::FindModule(bool& found, bool quiet, bool required)
       // a fatal error if the package is not found.
       std::string req = this->Name;
       req += "_FIND_REQUIRED";
-      m_Makefile->AddDefinition(req.c_str(), "1");
+      this->Makefile->AddDefinition(req.c_str(), "1");
       }
 
     // Load the module we found.
@@ -330,7 +330,7 @@ bool cmFindPackageCommand::FindConfig()
   std::string init = this->SearchForConfig();
 
   // Store the entry in the cache so it can be set by the user.
-  m_Makefile->AddCacheDefinition(this->Variable.c_str(),
+  this->Makefile->AddCacheDefinition(this->Variable.c_str(),
                                  init.c_str(),
                                  help.c_str(),
                                  cmCacheManager::PATH);
@@ -393,7 +393,7 @@ std::string cmFindPackageCommand::SearchForConfig() const
 //----------------------------------------------------------------------------
 bool cmFindPackageCommand::ReadListFile(const char* f)
 {
-  if(m_Makefile->ReadListFile(m_Makefile->GetCurrentListFile(),f))
+  if(this->Makefile->ReadListFile(this->Makefile->GetCurrentListFile(),f))
     {
     return true;
     }
diff --git a/Source/cmFindPathCommand.cxx b/Source/cmFindPathCommand.cxx
index eecdfa1..c24d127 100644
--- a/Source/cmFindPathCommand.cxx
+++ b/Source/cmFindPathCommand.cxx
@@ -64,7 +64,7 @@ bool cmFindPathCommand::InitialPass(std::vector<std::string> const& argsIn)
     {
     return true;
     }
-  std::string ff = m_Makefile->GetSafeDefinition("CMAKE_FIND_FRAMEWORK");
+  std::string ff = this->Makefile->GetSafeDefinition("CMAKE_FIND_FRAMEWORK");
   bool supportFrameworks = true;
   if( ff.size() == 0 || ff == "NEVER" )
     {
@@ -108,7 +108,7 @@ bool cmFindPathCommand::InitialPass(std::vector<std::string> const& argsIn)
         }
       if(result.size() != 0)
         {
-        m_Makefile->AddCacheDefinition(this->VariableName.c_str(),
+        this->Makefile->AddCacheDefinition(this->VariableName.c_str(),
                                        result.c_str(),
                                        this->VariableDocumentation.c_str(),
                                        (this->IncludeFileInPath) ? 
@@ -117,7 +117,7 @@ bool cmFindPathCommand::InitialPass(std::vector<std::string> const& argsIn)
         }
       }
     }
-  m_Makefile->AddCacheDefinition(this->VariableName.c_str(),
+  this->Makefile->AddCacheDefinition(this->VariableName.c_str(),
                                  (this->VariableName + "-NOTFOUND").c_str(),
                                  this->VariableDocumentation.c_str(),
                                  (this->IncludeFileInPath) ? 
diff --git a/Source/cmFindProgramCommand.cxx b/Source/cmFindProgramCommand.cxx
index f479ccd..5b08fc8 100644
--- a/Source/cmFindProgramCommand.cxx
+++ b/Source/cmFindProgramCommand.cxx
@@ -53,14 +53,14 @@ bool cmFindProgramCommand::InitialPass(std::vector<std::string> const& argsIn)
   if(result != "")
     {
     // Save the value in the cache
-    m_Makefile->AddCacheDefinition(this->VariableName.c_str(),
-                                   result.c_str(),
-                                   this->VariableDocumentation.c_str(),
-                                   cmCacheManager::FILEPATH);
+    this->Makefile->AddCacheDefinition(this->VariableName.c_str(),
+                                       result.c_str(),
+                                       this->VariableDocumentation.c_str(),
+                                       cmCacheManager::FILEPATH);
     
     return true;
     }
-  m_Makefile->AddCacheDefinition(this->VariableName.c_str(),
+  this->Makefile->AddCacheDefinition(this->VariableName.c_str(),
                                  (this->VariableName + "-NOTFOUND").c_str(),
                                  this->VariableDocumentation.c_str(),
                                  cmCacheManager::FILEPATH);
diff --git a/Source/cmForEachCommand.cxx b/Source/cmForEachCommand.cxx
index 4c05cf0..c9b39dc 100644
--- a/Source/cmForEachCommand.cxx
+++ b/Source/cmForEachCommand.cxx
@@ -21,49 +21,49 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
 {
   // Prevent recusion and don't let this blobker block its own
   // commands.
-  if (m_Executing)
+  if (this->Executing)
     {
     return false;
     }
   
   // at end of for each execute recorded commands
-  if (cmSystemTools::LowerCase(lff.m_Name) == "endforeach")
+  if (cmSystemTools::LowerCase(lff.Name) == "endforeach")
     {
     std::vector<std::string> expandedArguments;
-    mf.ExpandArguments(lff.m_Arguments, expandedArguments);
-    if(!expandedArguments.empty() && (expandedArguments[0] == m_Args[0]))
+    mf.ExpandArguments(lff.Arguments, expandedArguments);
+    if(!expandedArguments.empty() && (expandedArguments[0] == this->Args[0]))
       {
       // store the old value
       std::string oldDef;
-      if (mf.GetDefinition(m_Args[0].c_str()))
+      if (mf.GetDefinition(this->Args[0].c_str()))
         {
-        oldDef = mf.GetDefinition(m_Args[0].c_str());
+        oldDef = mf.GetDefinition(this->Args[0].c_str());
         }
-      m_Executing = true;
-      std::vector<std::string>::const_iterator j = m_Args.begin();
+      this->Executing = true;
+      std::vector<std::string>::const_iterator j = this->Args.begin();
       ++j;
       
       std::string tmps;
       cmListFileArgument arg;
-      for( ; j != m_Args.end(); ++j)
+      for( ; j != this->Args.end(); ++j)
         {   
         // set the variable to the loop value
-        mf.AddDefinition(m_Args[0].c_str(),j->c_str());
+        mf.AddDefinition(this->Args[0].c_str(),j->c_str());
         // Invoke all the functions that were collected in the block.
-        for(unsigned int c = 0; c < m_Functions.size(); ++c)
+        for(unsigned int c = 0; c < this->Functions.size(); ++c)
           {
-          mf.ExecuteCommand(m_Functions[c]);
+          mf.ExecuteCommand(this->Functions[c]);
           }
         }
       // restore the variable to its prior value
-      mf.AddDefinition(m_Args[0].c_str(),oldDef.c_str());
+      mf.AddDefinition(this->Args[0].c_str(),oldDef.c_str());
       mf.RemoveFunctionBlocker(lff);
       return true;
       }
     }
 
   // record the command
-  m_Functions.push_back(lff);
+  this->Functions.push_back(lff);
   
   // always return true
   return true;
@@ -72,11 +72,11 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
 bool cmForEachFunctionBlocker::
 ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf)
 {
-  if(cmSystemTools::LowerCase(lff.m_Name) == "endforeach")
+  if(cmSystemTools::LowerCase(lff.Name) == "endforeach")
     {
     std::vector<std::string> expandedArguments;
-    mf.ExpandArguments(lff.m_Arguments, expandedArguments);
-    if(!expandedArguments.empty() && (expandedArguments[0] == m_Args[0]))
+    mf.ExpandArguments(lff.Arguments, expandedArguments);
+    if(!expandedArguments.empty() && (expandedArguments[0] == this->Args[0]))
       {
       return true;
       }
@@ -163,18 +163,18 @@ bool cmForEachCommand::InitialPass(std::vector<std::string> const& args)
           break;
           }
         }
-      f->m_Args = range;
+      f->Args = range;
       }
     else
       {
-      f->m_Args = args;
+      f->Args = args;
       }
     }
   else
     {
-    f->m_Args = args;
+    f->Args = args;
     }
-  m_Makefile->AddFunctionBlocker(f);
+  this->Makefile->AddFunctionBlocker(f);
   
   return true;
 }
diff --git a/Source/cmForEachCommand.h b/Source/cmForEachCommand.h
index 6d6353d..5a30359 100644
--- a/Source/cmForEachCommand.h
+++ b/Source/cmForEachCommand.h
@@ -29,16 +29,16 @@
 class cmForEachFunctionBlocker : public cmFunctionBlocker
 {
 public:
-  cmForEachFunctionBlocker() {m_Executing = false;}
+  cmForEachFunctionBlocker() {this->Executing = false;}
   virtual ~cmForEachFunctionBlocker() {}
   virtual bool IsFunctionBlocked(const cmListFileFunction& lff,
                                  cmMakefile &mf);
   virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf);
   virtual void ScopeEnded(cmMakefile &mf);
   
-  std::vector<std::string> m_Args;
-  std::vector<cmListFileFunction> m_Functions;
-  bool m_Executing;
+  std::vector<std::string> Args;
+  std::vector<cmListFileFunction> Functions;
+  bool Executing;
 };
 
 /** \class cmForEachCommand
diff --git a/Source/cmGeneratedFileStream.cxx b/Source/cmGeneratedFileStream.cxx
index 1833b94..70d1c77 100644
--- a/Source/cmGeneratedFileStream.cxx
+++ b/Source/cmGeneratedFileStream.cxx
@@ -39,12 +39,12 @@ cmGeneratedFileStream::cmGeneratedFileStream():
 //----------------------------------------------------------------------------
 cmGeneratedFileStream::cmGeneratedFileStream(const char* name, bool quiet):
   cmGeneratedFileStreamBase(name),
-  Stream(m_TempName.c_str())
+  Stream(TempName.c_str())
 {
   // Check if the file opened.
   if(!*this && !quiet)
     {
-    cmSystemTools::Error("Cannot open file for write: ", m_TempName.c_str());
+    cmSystemTools::Error("Cannot open file for write: ", this->TempName.c_str());
     cmSystemTools::ReportLastSystemError("");
     }
 }
@@ -57,7 +57,7 @@ cmGeneratedFileStream::~cmGeneratedFileStream()
   // stream will be destroyed which will close the temporary file.
   // Finally the base destructor will be called to replace the
   // destination file.
-  m_Okay = (*this)?true:false;
+  this->Okay = (*this)?true:false;
 }
 
 //----------------------------------------------------------------------------
@@ -70,17 +70,17 @@ cmGeneratedFileStream::Open(const char* name, bool quiet, bool binaryFlag)
   // Open the temporary output file.
   if ( binaryFlag )
     {
-    this->Stream::open(m_TempName.c_str(), std::ios::out | std::ios::binary);
+    this->Stream::open(this->TempName.c_str(), std::ios::out | std::ios::binary);
     }
   else
     {
-    this->Stream::open(m_TempName.c_str(), std::ios::out);
+    this->Stream::open(this->TempName.c_str(), std::ios::out);
     }
 
   // Check if the file opened.
   if(!*this && !quiet)
     {
-    cmSystemTools::Error("Cannot open file for write: ", m_TempName.c_str());
+    cmSystemTools::Error("Cannot open file for write: ", this->TempName.c_str());
     cmSystemTools::ReportLastSystemError("");
     }
   return *this;
@@ -91,7 +91,7 @@ cmGeneratedFileStream&
 cmGeneratedFileStream::Close()
 {
   // Save whether the temporary output file is valid before closing.
-  m_Okay = (*this)?true:false;
+  this->Okay = (*this)?true:false;
 
   // Close the temporary output file.
   this->Stream::close();
@@ -105,40 +105,40 @@ cmGeneratedFileStream::Close()
 //----------------------------------------------------------------------------
 void cmGeneratedFileStream::SetCopyIfDifferent(bool copy_if_different)
 {
-  m_CopyIfDifferent = copy_if_different;
+  this->CopyIfDifferent = copy_if_different;
 }
 
 //----------------------------------------------------------------------------
 void cmGeneratedFileStream::SetCompression(bool compression)
 {
-  m_Compress = compression;
+  this->Compress = compression;
 }
 
 //----------------------------------------------------------------------------
 void cmGeneratedFileStream::SetCompressionExtraExtension(bool ext)
 {
-  m_CompressExtraExtension = ext;
+  this->CompressExtraExtension = ext;
 }
 
 //----------------------------------------------------------------------------
 cmGeneratedFileStreamBase::cmGeneratedFileStreamBase():
-  m_Name(),
-  m_TempName(),
-  m_CopyIfDifferent(false),
-  m_Okay(false),
-  m_Compress(false),
-  m_CompressExtraExtension(true)
+  Name(),
+  TempName(),
+  CopyIfDifferent(false),
+  Okay(false),
+  Compress(false),
+  CompressExtraExtension(true)
 {
 }
 
 //----------------------------------------------------------------------------
 cmGeneratedFileStreamBase::cmGeneratedFileStreamBase(const char* name):
-  m_Name(),
-  m_TempName(),
-  m_CopyIfDifferent(false),
-  m_Okay(false),
-  m_Compress(false),
-  m_CompressExtraExtension(true)
+  Name(),
+  TempName(),
+  CopyIfDifferent(false),
+  Okay(false),
+  Compress(false),
+  CompressExtraExtension(true)
 {
   this->Open(name);
 }
@@ -153,41 +153,41 @@ cmGeneratedFileStreamBase::~cmGeneratedFileStreamBase()
 void cmGeneratedFileStreamBase::Open(const char* name)
 {
   // Save the original name of the file.
-  m_Name = name;
+  this->Name = name;
 
   // Create the name of the temporary file.
-  m_TempName = name;
-  m_TempName += ".tmp";
+  this->TempName = name;
+  this->TempName += ".tmp";
 
   // Make sure the temporary file that will be used is not present.
-  cmSystemTools::RemoveFile(m_TempName.c_str());
+  cmSystemTools::RemoveFile(this->TempName.c_str());
 
-  std::string dir = cmSystemTools::GetFilenamePath(m_TempName);
+  std::string dir = cmSystemTools::GetFilenamePath(this->TempName);
   cmSystemTools::MakeDirectory(dir.c_str());
 }
 
 //----------------------------------------------------------------------------
 void cmGeneratedFileStreamBase::Close()
 {
-  std::string resname = m_Name;
-  if ( m_Compress && m_CompressExtraExtension )
+  std::string resname = this->Name;
+  if ( this->Compress && this->CompressExtraExtension )
     {
     resname += ".gz";
     }
 
   // Only consider replacing the destination file if no error
   // occurred.
-  if(!m_Name.empty() &&
-    m_Okay &&
-    (!m_CopyIfDifferent ||
-     cmSystemTools::FilesDiffer(m_TempName.c_str(), resname.c_str())))
+  if(!this->Name.empty() &&
+    this->Okay &&
+    (!this->CopyIfDifferent ||
+     cmSystemTools::FilesDiffer(this->TempName.c_str(), resname.c_str())))
     {
     // The destination is to be replaced.  Rename the temporary to the
     // destination atomically.
-    if ( m_Compress )
+    if ( this->Compress )
       {
-      std::string gzname = m_TempName + ".temp.gz";
-      if ( this->CompressFile(m_TempName.c_str(), gzname.c_str()) )
+      std::string gzname = this->TempName + ".temp.gz";
+      if ( this->CompressFile(this->TempName.c_str(), gzname.c_str()) )
         {
         this->RenameFile(gzname.c_str(), resname.c_str());
         }
@@ -195,14 +195,14 @@ void cmGeneratedFileStreamBase::Close()
       }
     else
       {
-      this->RenameFile(m_TempName.c_str(), resname.c_str());
+      this->RenameFile(this->TempName.c_str(), resname.c_str());
       }
     }
 
   // Else, the destination was not replaced.
   //
   // Always delete the temporary file. We never want it to stay around.
-  cmSystemTools::RemoveFile(m_TempName.c_str());
+  cmSystemTools::RemoveFile(this->TempName.c_str());
 }
 
 //----------------------------------------------------------------------------
@@ -299,8 +299,8 @@ void cmGeneratedFileStream::SetName(const char* fname)
 {
   if ( !fname )
     {
-    m_Name = "";
+    this->Name = "";
     return;
     }
-  m_Name = fname;
+  this->Name = fname;
 }
diff --git a/Source/cmGeneratedFileStream.h b/Source/cmGeneratedFileStream.h
index fb49081..9a34645 100644
--- a/Source/cmGeneratedFileStream.h
+++ b/Source/cmGeneratedFileStream.h
@@ -41,7 +41,7 @@ protected:
 
   // Internal methods to handle the temporary file.  Open is always
   // called before the real stream is opened.  Close is always called
-  // after the real stream is closed and m_Okay is set to whether the
+  // after the real stream is closed and Okay is set to whether the
   // real stream was still valid for writing when it was closed.
   void Open(const char* name);
   void Close();
@@ -53,22 +53,22 @@ protected:
   int CompressFile(const char* oldname, const char* newname);
 
   // The name of the final destination file for the output.
-  std::string m_Name;
+  std::string Name;
 
   // The name of the temporary file.
-  std::string m_TempName;
+  std::string TempName;
 
   // Whether to do a copy-if-different.
-  bool m_CopyIfDifferent;
+  bool CopyIfDifferent;
 
   // Whether the real file stream was valid when it was closed.
-  bool m_Okay;
+  bool Okay;
 
   // Whether the destionation file is compressed
-  bool m_Compress;
+  bool Compress;
 
   // Whether the destionation file is compressed
-  bool m_CompressExtraExtension;
+  bool CompressExtraExtension;
 };
 
 /** \class cmGeneratedFileStream
diff --git a/Source/cmGetCMakePropertyCommand.cxx b/Source/cmGetCMakePropertyCommand.cxx
index 296ff0c..65e7ed4 100644
--- a/Source/cmGetCMakePropertyCommand.cxx
+++ b/Source/cmGetCMakePropertyCommand.cxx
@@ -39,7 +39,7 @@ bool cmGetCMakePropertyCommand::InitialPass(
       {
       cacheonly = 1;
       }
-    std::vector<std::string> vars = m_Makefile->GetDefinitions(cacheonly);
+    std::vector<std::string> vars = this->Makefile->GetDefinitions(cacheonly);
     for ( cc = 0; cc < vars.size(); cc ++ )
       {
       if ( cc > 0 )
@@ -52,9 +52,9 @@ bool cmGetCMakePropertyCommand::InitialPass(
   else if ( args[1] == "COMMANDS" )
     {
     cmake::RegisteredCommandsMap::iterator cmds 
-        = m_Makefile->GetCMakeInstance()->GetCommands()->begin();
+        = this->Makefile->GetCMakeInstance()->GetCommands()->begin();
     for (cc=0 ; 
-      cmds != m_Makefile->GetCMakeInstance()->GetCommands()->end(); 
+      cmds != this->Makefile->GetCMakeInstance()->GetCommands()->end(); 
       ++ cmds )
       {
       if ( cc > 0 )
@@ -67,7 +67,7 @@ bool cmGetCMakePropertyCommand::InitialPass(
     }
   else if ( args[1] == "MACROS" )
     {
-    m_Makefile->GetListOfMacros(output);
+    this->Makefile->GetListOfMacros(output);
     }
   else
     {
@@ -75,7 +75,7 @@ bool cmGetCMakePropertyCommand::InitialPass(
     this->SetError(emsg.c_str());
     return false;
     }
-  m_Makefile->AddDefinition(variable.c_str(), output.c_str());
+  this->Makefile->AddDefinition(variable.c_str(), output.c_str());
   
   return true;
 }
diff --git a/Source/cmGetDirectoryPropertyCommand.cxx b/Source/cmGetDirectoryPropertyCommand.cxx
index 735a03d..79a18ad 100644
--- a/Source/cmGetDirectoryPropertyCommand.cxx
+++ b/Source/cmGetDirectoryPropertyCommand.cxx
@@ -35,7 +35,7 @@ bool cmGetDirectoryPropertyCommand::InitialPass(
   std::string output = "";
     
   // get the directory argument if there is one
-  cmMakefile *dir = m_Makefile;
+  cmMakefile *dir = this->Makefile;
   if (*i == "DIRECTORY")
     {
     ++i;
@@ -49,13 +49,13 @@ bool cmGetDirectoryPropertyCommand::InitialPass(
     // make sure the start dir is a full path
     if (!cmSystemTools::FileIsFullPath(sd.c_str()))
       {
-      sd = m_Makefile->GetStartDirectory();
+      sd = this->Makefile->GetStartDirectory();
       sd += "/";
       sd += *i;
       }
     // lookup the makefile from the directory name
     cmLocalGenerator *lg = 
-      m_Makefile->GetLocalGenerator()->GetGlobalGenerator()->
+      this->Makefile->GetLocalGenerator()->GetGlobalGenerator()->
       FindLocalGenerator(sd.c_str());
     if (!lg)
       {
@@ -151,13 +151,13 @@ bool cmGetDirectoryPropertyCommand::InitialPass(
     const char *prop = dir->GetProperty(i->c_str());
     if (prop)
       {
-      m_Makefile->AddDefinition(variable.c_str(), prop);
+      this->Makefile->AddDefinition(variable.c_str(), prop);
       return true;
       }
-    m_Makefile->AddDefinition(variable.c_str(), "");
+    this->Makefile->AddDefinition(variable.c_str(), "");
     return true;
     }
-  m_Makefile->AddDefinition(variable.c_str(), output.c_str());
+  this->Makefile->AddDefinition(variable.c_str(), output.c_str());
   
   return true;
 }
diff --git a/Source/cmGetFilenameComponentCommand.cxx b/Source/cmGetFilenameComponentCommand.cxx
index 4f88c4c..d8b29d3 100644
--- a/Source/cmGetFilenameComponentCommand.cxx
+++ b/Source/cmGetFilenameComponentCommand.cxx
@@ -30,7 +30,7 @@ bool cmGetFilenameComponentCommand::InitialPass(std::vector<std::string> const&
   // already, if so use that value
   if(args.size() == 4 && args[3] == "CACHE")
     {
-    const char* cacheValue = m_Makefile->GetDefinition(args[0].c_str());
+    const char* cacheValue = this->Makefile->GetDefinition(args[0].c_str());
     if(cacheValue && !cmSystemTools::IsNOTFOUND(cacheValue))
       {
       return true;
@@ -79,7 +79,7 @@ bool cmGetFilenameComponentCommand::InitialPass(std::vector<std::string> const&
     // current source directory.
     if(!cmSystemTools::FileIsFullPath(filename.c_str()))
       {
-      std::string fname = m_Makefile->GetCurrentDirectory();
+      std::string fname = this->Makefile->GetCurrentDirectory();
       if(!fname.empty())
         {
         fname += "/";
@@ -102,13 +102,13 @@ bool cmGetFilenameComponentCommand::InitialPass(std::vector<std::string> const&
     {
     if(programArgs.size() && storeArgs.size())
       {
-      m_Makefile->AddCacheDefinition(storeArgs.c_str(),
+      this->Makefile->AddCacheDefinition(storeArgs.c_str(),
                                      programArgs.c_str(),
                                      "",
                                      args[2] == "PATH" ? cmCacheManager::FILEPATH
                                      : cmCacheManager::STRING);
       }
-    m_Makefile->AddCacheDefinition(args[0].c_str(),
+    this->Makefile->AddCacheDefinition(args[0].c_str(),
                                    result.c_str(),
                                    "",
                                    args[2] == "PATH" ? cmCacheManager::FILEPATH
@@ -118,9 +118,9 @@ bool cmGetFilenameComponentCommand::InitialPass(std::vector<std::string> const&
     {
     if(programArgs.size() && storeArgs.size())
       {
-      m_Makefile->AddDefinition(storeArgs.c_str(), programArgs.c_str());
+      this->Makefile->AddDefinition(storeArgs.c_str(), programArgs.c_str());
       }
-    m_Makefile->AddDefinition(args[0].c_str(), result.c_str());
+    this->Makefile->AddDefinition(args[0].c_str(), result.c_str());
     }
 
   return true;
diff --git a/Source/cmGetSourceFilePropertyCommand.cxx b/Source/cmGetSourceFilePropertyCommand.cxx
index 51404ef..3c149a4 100644
--- a/Source/cmGetSourceFilePropertyCommand.cxx
+++ b/Source/cmGetSourceFilePropertyCommand.cxx
@@ -29,19 +29,19 @@ bool cmGetSourceFilePropertyCommand::InitialPass(
     }
   const char* var = args[0].c_str();
   const char* file = args[1].c_str();
-  cmSourceFile* sf = m_Makefile->GetSource(file);
+  cmSourceFile* sf = this->Makefile->GetSource(file);
 
   if(sf)
     {
     const char *prop = sf->GetProperty(args[2].c_str());
     if (prop)
       {
-      m_Makefile->AddDefinition(var, prop);
+      this->Makefile->AddDefinition(var, prop);
       return true;
       }
     }
 
-  m_Makefile->AddDefinition(var, "NOTFOUND");
+  this->Makefile->AddDefinition(var, "NOTFOUND");
   return true;
 }
 
diff --git a/Source/cmGetTargetPropertyCommand.cxx b/Source/cmGetTargetPropertyCommand.cxx
index 45164da..5a13f60 100644
--- a/Source/cmGetTargetPropertyCommand.cxx
+++ b/Source/cmGetTargetPropertyCommand.cxx
@@ -28,7 +28,7 @@ bool cmGetTargetPropertyCommand::InitialPass(
   const char* var = args[0].c_str();
   const char* targetName = args[1].c_str();
 
-  cmTarget *tgt = m_Makefile->GetLocalGenerator()->GetGlobalGenerator()
+  cmTarget *tgt = this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
     ->FindTarget(0,targetName);
   if (tgt)
     {
@@ -36,11 +36,11 @@ bool cmGetTargetPropertyCommand::InitialPass(
     const char *prop = target.GetProperty(args[2].c_str());
     if (prop)
       {
-      m_Makefile->AddDefinition(var, prop);
+      this->Makefile->AddDefinition(var, prop);
       return true;
       }
     }
-  m_Makefile->AddDefinition(var, "NOTFOUND");
+  this->Makefile->AddDefinition(var, "NOTFOUND");
   return true;
 }
 
diff --git a/Source/cmGetTestPropertyCommand.cxx b/Source/cmGetTestPropertyCommand.cxx
index d48cd6c..d4cae24 100644
--- a/Source/cmGetTestPropertyCommand.cxx
+++ b/Source/cmGetTestPropertyCommand.cxx
@@ -31,17 +31,17 @@ bool cmGetTestPropertyCommand::InitialPass(
 
   std::string testName = args[0];
   std::string var = args[2];
-  cmTest *test = m_Makefile->GetTest(testName.c_str());
+  cmTest *test = this->Makefile->GetTest(testName.c_str());
   if (test)
     {
     const char *prop = test->GetProperty(args[1].c_str());
     if (prop)
       {
-      m_Makefile->AddDefinition(var.c_str(), prop);
+      this->Makefile->AddDefinition(var.c_str(), prop);
       return true;
       }
     }
-  m_Makefile->AddDefinition(var.c_str(), "NOTFOUND");
+  this->Makefile->AddDefinition(var.c_str(), "NOTFOUND");
   return true;
 }
 
diff --git a/Source/cmGlob.cxx b/Source/cmGlob.cxx
index bc1c2c1..6a793e2 100644
--- a/Source/cmGlob.cxx
+++ b/Source/cmGlob.cxx
@@ -42,13 +42,13 @@ public:
 
 cmGlob::cmGlob()
 {
-  m_Internals = new cmGlobInternal;
-  m_Recurse = false;
+  this->Internals = new cmGlobInternal;
+  this->Recurse = false;
 }
 
 cmGlob::~cmGlob()
 {
-  delete m_Internals;
+  delete this->Internals;
 }
 
 void cmGlob::Escape(int ch, char* buffer)
@@ -73,7 +73,7 @@ void cmGlob::Escape(int ch, char* buffer)
 
 std::vector<std::string>& cmGlob::GetFiles()
 {
-  return m_Internals->Files;
+  return this->Internals->Files;
 }
 
 std::string cmGlob::ConvertExpression(const std::string& expr)
@@ -200,9 +200,9 @@ void cmGlob::RecurseDirectory(std::string::size_type start,
 
     if ( !dir_only || !cmsys::SystemTools::FileIsDirectory(realname.c_str()) )
       {
-      if ( m_Internals->Expressions[m_Internals->Expressions.size()-1].find(fname.c_str()) )
+      if ( this->Internals->Expressions[this->Internals->Expressions.size()-1].find(fname.c_str()) )
         {
-        m_Internals->Files.push_back(realname);
+        this->Internals->Files.push_back(realname);
         }
       }
     if ( cmsys::SystemTools::FileIsDirectory(realname.c_str()) )
@@ -216,8 +216,8 @@ void cmGlob::ProcessDirectory(std::string::size_type start,
   const std::string& dir, bool dir_only)
 {
   //std::cout << "ProcessDirectory: " << dir << std::endl;
-  bool last = ( start == m_Internals->Expressions.size()-1 );
-  if ( last && m_Recurse )
+  bool last = ( start == this->Internals->Expressions.size()-1 );
+  if ( last && this->Recurse )
     {
     this->RecurseDirectory(start, dir, dir_only);
     return;
@@ -264,7 +264,7 @@ void cmGlob::ProcessDirectory(std::string::size_type start,
       }
 
     //std::cout << "Look at file: " << fname << std::endl;
-    //std::cout << "Match: " << m_Internals->TextExpressions[start].c_str() << std::endl;
+    //std::cout << "Match: " << this->Internals->TextExpressions[start].c_str() << std::endl;
     //std::cout << "Full name: " << fullname << std::endl;
 
     if ( (!dir_only || !last) && !cmsys::SystemTools::FileIsDirectory(realname.c_str()) )
@@ -272,11 +272,11 @@ void cmGlob::ProcessDirectory(std::string::size_type start,
       continue;
       }
 
-    if ( m_Internals->Expressions[start].find(fname.c_str()) )
+    if ( this->Internals->Expressions[start].find(fname.c_str()) )
       {
       if ( last )
         {
-        m_Internals->Files.push_back(realname);
+        this->Internals->Files.push_back(realname);
         }
       else
         {
@@ -292,8 +292,8 @@ bool cmGlob::FindFiles(const std::string& inexpr)
   std::string::size_type cc;
   std::string expr = inexpr;
 
-  m_Internals->Expressions.clear();
-  m_Internals->Files.clear();
+  this->Internals->Expressions.clear();
+  this->Internals->Files.clear();
 
   if ( !cmsys::SystemTools::FileIsFullPath(expr.c_str()) )
     {
@@ -393,9 +393,9 @@ bool cmGlob::FindFiles(const std::string& inexpr)
 
 void cmGlob::AddExpression(const char* expr)
 {
-  m_Internals->Expressions.push_back(
+  this->Internals->Expressions.push_back(
     cmsys::RegularExpression(
       this->ConvertExpression(expr).c_str()));
-  m_Internals->TextExpressions.push_back(this->ConvertExpression(expr));
+  this->Internals->TextExpressions.push_back(this->ConvertExpression(expr));
 }
 
diff --git a/Source/cmGlob.h b/Source/cmGlob.h
index 62e9d94..ad27a59 100644
--- a/Source/cmGlob.h
+++ b/Source/cmGlob.h
@@ -41,8 +41,8 @@ public:
   //! Set recurse to true to match subdirectories.
   void RecurseOn() { this->SetRecurse(true); }
   void RecurseOff() { this->SetRecurse(false); }
-  void SetRecurse(bool i) { m_Recurse = i; }
-  bool GetRecurse() { return m_Recurse; }
+  void SetRecurse(bool i) { this->Recurse = i; }
+  bool GetRecurse() { return this->Recurse; }
 
 protected:
   //! Process directory
@@ -65,8 +65,8 @@ protected:
   //! Add regular expression
   void AddExpression(const char* expr);
 
-  cmGlobInternal* m_Internals;
-  bool m_Recurse;
+  cmGlobInternal* Internals;
+  bool Recurse;
 };
 
 
diff --git a/Source/cmGlobalBorlandMakefileGenerator.cxx b/Source/cmGlobalBorlandMakefileGenerator.cxx
index dd2f73c..61cd883 100644
--- a/Source/cmGlobalBorlandMakefileGenerator.cxx
+++ b/Source/cmGlobalBorlandMakefileGenerator.cxx
@@ -21,16 +21,16 @@
 
 cmGlobalBorlandMakefileGenerator::cmGlobalBorlandMakefileGenerator()
 {
-  m_EmptyRuleHackDepends = "NUL";
-  m_FindMakeProgramFile = "CMakeBorlandFindMake.cmake";
-  m_ForceUnixPaths = false;
+  this->EmptyRuleHackDepends = "NUL";
+  this->FindMakeProgramFile = "CMakeBorlandFindMake.cmake";
+  this->ForceUnixPaths = false;
 }
 
 
 void cmGlobalBorlandMakefileGenerator::EnableLanguage(std::vector<std::string>const& l,
                                                       cmMakefile *mf)
 {
-  std::string outdir = m_CMakeInstance->GetStartOutputDirectory();
+  std::string outdir = this->CMakeInstance->GetStartOutputDirectory();
   mf->AddDefinition("BORLAND", "1");
   mf->AddDefinition("CMAKE_GENERATOR_CC", "bcc32");
   mf->AddDefinition("CMAKE_GENERATOR_CXX", "bcc32"); 
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index f97e83a..3ceeb2e 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -32,33 +32,33 @@ int cmGlobalGenerator::s_TryCompileTimeout = 0;
 cmGlobalGenerator::cmGlobalGenerator()
 {
   // by default use the native paths
-  m_ForceUnixPaths = false;
+  this->ForceUnixPaths = false;
 }
 
 cmGlobalGenerator::~cmGlobalGenerator()
 { 
   // Delete any existing cmLocalGenerators
   unsigned int i;
-  for (i = 0; i < m_LocalGenerators.size(); ++i)
+  for (i = 0; i < this->LocalGenerators.size(); ++i)
     {
-    delete m_LocalGenerators[i];
+    delete this->LocalGenerators[i];
     }
-  m_LocalGenerators.clear();
+  this->LocalGenerators.clear();
 }
 
 // Find the make program for the generator, required for try compiles
 void cmGlobalGenerator::FindMakeProgram(cmMakefile* mf)
 {
-  if(m_FindMakeProgramFile.size() == 0)
+  if(this->FindMakeProgramFile.size() == 0)
     {
     cmSystemTools::Error(
       "Generator implementation error, "
-      "all generators must specify m_FindMakeProgramFile");
+      "all generators must specify this->FindMakeProgramFile");
     }
   if(!mf->GetDefinition("CMAKE_MAKE_PROGRAM")
      || cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM")))
     {
-    std::string setMakeProgram = mf->GetModulesFile(m_FindMakeProgramFile.c_str());
+    std::string setMakeProgram = mf->GetModulesFile(this->FindMakeProgramFile.c_str());
     if(setMakeProgram.size())
       {
       mf->ReadListFile(0, setMakeProgram.c_str());
@@ -146,9 +146,9 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
   // If the configuration files path has been set,
   // then we are in a try compile and need to copy the enable language
   // files from the parent cmake bin dir, into the try compile bin dir
-  if(m_ConfiguredFilesPath.size())
+  if(this->ConfiguredFilesPath.size())
     {
-    std::string src = m_ConfiguredFilesPath;
+    std::string src = this->ConfiguredFilesPath;
     src += "/CMakeSystem.cmake";
     std::string dst = rootBin;
     dst += "/CMakeSystem.cmake";
@@ -162,7 +162,7 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
         continue;
         }
       const char* lang = l->c_str();
-      std::string src2 = m_ConfiguredFilesPath;
+      std::string src2 = this->ConfiguredFilesPath;
       src2 += "/CMake";
       src2 += lang;
       src2 += "Compiler.cmake";
@@ -171,7 +171,7 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
       dst2 += lang;
       dst2 += "Compiler.cmake";
       cmSystemTools::CopyFileIfDifferent(src2.c_str(), dst2.c_str()); 
-      src2 = m_ConfiguredFilesPath;
+      src2 = this->ConfiguredFilesPath;
       src2 += "/CMake";
       src2 += lang;
       src2 += "Platform.cmake";
@@ -181,7 +181,7 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
       dst2 += "Platform.cmake";
       cmSystemTools::CopyFileIfDifferent(src2.c_str(), dst2.c_str());
       }
-    rootBin = m_ConfiguredFilesPath;
+    rootBin = this->ConfiguredFilesPath;
     }
 
   // find and make sure CMAKE_MAKE_PROGRAM is defined
@@ -246,7 +246,7 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
     unsigned int cacheMinor = mf->GetCacheMinorVersion();
     unsigned int selfMajor = cmMakefile::GetMajorVersion();
     unsigned int selfMinor = cmMakefile::GetMinorVersion();
-    if((m_CMakeInstance->GetIsInTryCompile() ||
+    if((this->CMakeInstance->GetIsInTryCompile() ||
         (selfMajor == cacheMajor && selfMinor == cacheMinor))
        && !mf->GetDefinition(loadedLang.c_str()))
       {
@@ -268,7 +268,7 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
       
     if(!this->GetLanguageEnabled(lang) )
       {  
-      if (m_CMakeInstance->GetIsInTryCompile())
+      if (this->CMakeInstance->GetIsInTryCompile())
         {
         cmSystemTools::Error("This should not have happen. "
                              "If you see this message, you are probably using a "
@@ -368,7 +368,7 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
     // If the language is untested then test it now with a try compile.
     if(needTestLanguage[lang])
       {
-      if (!m_CMakeInstance->GetIsInTryCompile())
+      if (!this->CMakeInstance->GetIsInTryCompile())
         {
         std::string testLang = "CMakeTest";
         testLang += lang;
@@ -438,9 +438,9 @@ const char* cmGlobalGenerator::GetLanguageOutputExtensionForLanguage(const char*
     {
     return "";
     }
-  if(m_LanguageToOutputExtension.count(lang) > 0)
+  if(this->LanguageToOutputExtension.count(lang) > 0)
     {
-    return m_LanguageToOutputExtension[lang].c_str();
+    return this->LanguageToOutputExtension[lang].c_str();
     }
   return "";
 }
@@ -457,7 +457,7 @@ const char* cmGlobalGenerator::GetLanguageOutputExtensionFromExtension(const cha
     // if no language is found then check to see if it is already an
     // ouput extension for some language.  In that case it should be ignored
     // and in this map, so it will not be compiled but will just be used.
-    if(m_OutputExtensions.count(ext))
+    if(this->OutputExtensions.count(ext))
       {
       return ext;
       }
@@ -475,16 +475,16 @@ const char* cmGlobalGenerator::GetLanguageFromExtension(const char* ext)
     {
     ++ext;
     }
-  if(m_ExtensionToLanguage.count(ext) > 0)
+  if(this->ExtensionToLanguage.count(ext) > 0)
     {
-    return m_ExtensionToLanguage[ext].c_str();
+    return this->ExtensionToLanguage[ext].c_str();
     }
   return 0;
 }
 
 void cmGlobalGenerator::SetLanguageEnabled(const char* l, cmMakefile* mf)
 {
-  if(m_LanguageEnabled.count(l) > 0)
+  if(this->LanguageEnabled.count(l) > 0)
     {
     return;
     }
@@ -493,11 +493,11 @@ void cmGlobalGenerator::SetLanguageEnabled(const char* l, cmMakefile* mf)
   const char* outputExtension = mf->GetDefinition(outputExtensionVar.c_str());
   if(outputExtension)
     {
-    m_LanguageToOutputExtension[l] = outputExtension;
-    m_OutputExtensions[outputExtension] = outputExtension;
+    this->LanguageToOutputExtension[l] = outputExtension;
+    this->OutputExtensions[outputExtension] = outputExtension;
     if(outputExtension[0] == '.')
       {
-      m_OutputExtensions[outputExtension+1] = outputExtension+1;
+      this->OutputExtensions[outputExtension+1] = outputExtension+1;
       }
     }
   
@@ -508,7 +508,7 @@ void cmGlobalGenerator::SetLanguageEnabled(const char* l, cmMakefile* mf)
     {
     linkerPref = "None";
     }
-  m_LanguageToLinkerPreference[l] = linkerPref;
+  this->LanguageToLinkerPreference[l] = linkerPref;
   
   std::string extensionsVar = std::string("CMAKE_") + 
     std::string(l) + std::string("_SOURCE_FILE_EXTENSIONS");
@@ -521,15 +521,15 @@ void cmGlobalGenerator::SetLanguageEnabled(const char* l, cmMakefile* mf)
   for(std::vector<std::string>::iterator i = extensionList.begin();
       i != extensionList.end(); ++i)
     {
-    m_ExtensionToLanguage[*i] = l;
+    this->ExtensionToLanguage[*i] = l;
     }
   cmSystemTools::ExpandListArgument(ignoreExts, extensionList);
   for(std::vector<std::string>::iterator i = extensionList.begin();
       i != extensionList.end(); ++i)
     {
-    m_IgnoreExtensions[*i] = true;
+    this->IgnoreExtensions[*i] = true;
     }
-  m_LanguageEnabled[l] = true;
+  this->LanguageEnabled[l] = true;
 
 }
 bool cmGlobalGenerator::IgnoreFile(const char* l)
@@ -538,41 +538,41 @@ bool cmGlobalGenerator::IgnoreFile(const char* l)
     {
     return false;
     }
-  return (m_IgnoreExtensions.count(l) > 0);
+  return (this->IgnoreExtensions.count(l) > 0);
 }
 
 bool cmGlobalGenerator::GetLanguageEnabled(const char* l)
 {
-  return (m_LanguageEnabled.count(l) > 0);
+  return (this->LanguageEnabled.count(l) > 0);
 }
 
 void cmGlobalGenerator::ClearEnabledLanguages()
 {
-  m_LanguageEnabled.clear();
+  this->LanguageEnabled.clear();
 }
 
 void cmGlobalGenerator::Configure()
 {
   // Delete any existing cmLocalGenerators
   unsigned int i;
-  for (i = 0; i < m_LocalGenerators.size(); ++i)
+  for (i = 0; i < this->LocalGenerators.size(); ++i)
     {
-    delete m_LocalGenerators[i];
+    delete this->LocalGenerators[i];
     }
-  m_LocalGenerators.clear();
+  this->LocalGenerators.clear();
 
   // Setup relative path generation.
   this->ConfigureRelativePaths();
 
   // start with this directory
   cmLocalGenerator *lg = this->CreateLocalGenerator();
-  m_LocalGenerators.push_back(lg);
+  this->LocalGenerators.push_back(lg);
 
   // set the Start directories
   lg->GetMakefile()->SetStartDirectory
-    (m_CMakeInstance->GetStartDirectory());
+    (this->CMakeInstance->GetStartDirectory());
   lg->GetMakefile()->SetStartOutputDirectory
-    (m_CMakeInstance->GetStartOutputDirectory());
+    (this->CMakeInstance->GetStartOutputDirectory());
   lg->GetMakefile()->MakeStartDirectoriesCurrent();
   
   // now do it
@@ -581,7 +581,7 @@ void cmGlobalGenerator::Configure()
   // update the cache entry for the number of local generators, this is used
   // for progress
   char num[100];
-  sprintf(num,"%d",static_cast<int>(m_LocalGenerators.size()));
+  sprintf(num,"%d",static_cast<int>(this->LocalGenerators.size()));
   this->GetCMakeInstance()->AddCacheEntry
     ("CMAKE_NUMBER_OF_LOCAL_GENERATORS", num,
      "number of local generators", cmCacheManager::INTERNAL);
@@ -589,17 +589,17 @@ void cmGlobalGenerator::Configure()
   std::set<cmStdString> notFoundMap;
   // after it is all done do a ConfigureFinalPass
   cmCacheManager* manager = 0;
-  for (i = 0; i < m_LocalGenerators.size(); ++i)
+  for (i = 0; i < this->LocalGenerators.size(); ++i)
     {
-    manager = m_LocalGenerators[i]->GetMakefile()->GetCacheManager();
-    m_LocalGenerators[i]->ConfigureFinalPass();
+    manager = this->LocalGenerators[i]->GetMakefile()->GetCacheManager();
+    this->LocalGenerators[i]->ConfigureFinalPass();
     cmTargets & targets = 
-      m_LocalGenerators[i]->GetMakefile()->GetTargets(); 
+      this->LocalGenerators[i]->GetMakefile()->GetTargets(); 
     for (cmTargets::iterator l = targets.begin();
          l != targets.end(); l++)
       {
-      cmTarget::LinkLibraries libs = l->second.GetLinkLibraries();
-      for(cmTarget::LinkLibraries::iterator lib = libs.begin();
+      cmTarget::LinkLibraryVectorType libs = l->second.GetLinkLibraries();
+      for(cmTarget::LinkLibraryVectorType::iterator lib = libs.begin();
           lib != libs.end(); ++lib)
         {
         if(lib->first.size() > 9 && 
@@ -610,7 +610,7 @@ void cmGlobalGenerator::Configure()
           }
         }
       std::vector<std::string>& incs = 
-        m_LocalGenerators[i]->GetMakefile()->GetIncludeDirectories();
+        this->LocalGenerators[i]->GetMakefile()->GetIncludeDirectories();
       
       for( std::vector<std::string>::iterator lib = incs.begin();
            lib != incs.end(); ++lib)
@@ -622,9 +622,9 @@ void cmGlobalGenerator::Configure()
           notFoundMap.insert(varName);
           }
         }
-      m_CMakeInstance->UpdateProgress("Configuring", 
-                                      0.9f+0.1f*(i+1.0f)/m_LocalGenerators.size());
-      m_LocalGenerators[i]->GetMakefile()->CheckInfiniteLoops();
+      this->CMakeInstance->UpdateProgress("Configuring", 
+                                      0.9f+0.1f*(i+1.0f)/this->LocalGenerators.size());
+      this->LocalGenerators[i]->GetMakefile()->CheckInfiniteLoops();
       }
     }
 
@@ -651,12 +651,12 @@ void cmGlobalGenerator::Configure()
                          "Please set the following variables:\n",
                          notFoundVars.c_str());
     }
-  // at this point m_LocalGenerators has been filled,
+  // at this point this->LocalGenerators has been filled,
   // so create the map from project name to vector of local generators
   this->FillProjectMap();
-  if ( !m_CMakeInstance->GetScriptMode() )
+  if ( !this->CMakeInstance->GetScriptMode() )
     {
-    m_CMakeInstance->UpdateProgress("Configuring done", -1);
+    this->CMakeInstance->UpdateProgress("Configuring done", -1);
     }
 }
 
@@ -668,9 +668,9 @@ void cmGlobalGenerator::Generate()
   // Consolidate global targets
   cmTargets globalTargets;
   this->CreateDefaultGlobalTargets(&globalTargets);
-  for (i = 0; i < m_LocalGenerators.size(); ++i)
+  for (i = 0; i < this->LocalGenerators.size(); ++i)
     {
-    cmTargets* targets = &(m_LocalGenerators[i]->GetMakefile()->GetTargets());
+    cmTargets* targets = &(this->LocalGenerators[i]->GetMakefile()->GetTargets());
     cmTargets::iterator tarIt;
     for ( tarIt = targets->begin(); tarIt != targets->end(); ++ tarIt )
       {
@@ -682,21 +682,21 @@ void cmGlobalGenerator::Generate()
     }
   
   // Generate project files
-  for (i = 0; i < m_LocalGenerators.size(); ++i)
+  for (i = 0; i < this->LocalGenerators.size(); ++i)
     {
-    cmTargets* targets = &(m_LocalGenerators[i]->GetMakefile()->GetTargets());
+    cmTargets* targets = &(this->LocalGenerators[i]->GetMakefile()->GetTargets());
     cmTargets::iterator tit;
     for ( tit = globalTargets.begin(); tit != globalTargets.end(); ++ tit )
       {
       (*targets)[tit->first] = tit->second;
       }
-    m_LocalGenerators[i]->Generate();
-    m_LocalGenerators[i]->GenerateInstallRules();
-    m_LocalGenerators[i]->GenerateTestFiles();
-    m_CMakeInstance->UpdateProgress("Generating", 
-                                    (i+1.0f)/m_LocalGenerators.size());
+    this->LocalGenerators[i]->Generate();
+    this->LocalGenerators[i]->GenerateInstallRules();
+    this->LocalGenerators[i]->GenerateTestFiles();
+    this->CMakeInstance->UpdateProgress("Generating", 
+                                    (i+1.0f)/this->LocalGenerators.size());
     }
-  m_CMakeInstance->UpdateProgress("Generating done", -1);
+  this->CMakeInstance->UpdateProgress("Generating done", -1);
 }
 
 int cmGlobalGenerator::TryCompile(const char *srcdir, const char *bindir, 
@@ -705,7 +705,7 @@ int cmGlobalGenerator::TryCompile(const char *srcdir, const char *bindir,
                                   std::string *output, cmMakefile *mf)
 {
   std::string makeCommand = 
-    m_CMakeInstance->GetCacheManager()->GetCacheValue("CMAKE_MAKE_PROGRAM");
+    this->CMakeInstance->GetCacheManager()->GetCacheValue("CMAKE_MAKE_PROGRAM");
   if(makeCommand.size() == 0)
     {
     cmSystemTools::Error(
@@ -847,12 +847,12 @@ int cmGlobalGenerator::Build(
 
 void cmGlobalGenerator::AddLocalGenerator(cmLocalGenerator *lg)
 {
-  m_LocalGenerators.push_back(lg); 
+  this->LocalGenerators.push_back(lg); 
 
   // update progress
   // estimate how many lg there will be
   const char *numGenC = 
-    m_CMakeInstance->GetCacheManager()->GetCacheValue
+    this->CMakeInstance->GetCacheManager()->GetCacheValue
     ("CMAKE_NUMBER_OF_LOCAL_GENERATORS");
   
   if (!numGenC)
@@ -861,12 +861,12 @@ void cmGlobalGenerator::AddLocalGenerator(cmLocalGenerator *lg)
     }
   
   int numGen = atoi(numGenC);
-  float prog = 0.9f*m_LocalGenerators.size()/numGen;
+  float prog = 0.9f*this->LocalGenerators.size()/numGen;
   if (prog > 0.9f)
     {
     prog = 0.9f;
     }
-  m_CMakeInstance->UpdateProgress("Configuring", prog);
+  this->CMakeInstance->UpdateProgress("Configuring", prog);
 }
 
 cmLocalGenerator *cmGlobalGenerator::CreateLocalGenerator()
@@ -887,12 +887,12 @@ void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen )
                                           "make program",
                                           cmCacheManager::FILEPATH);
   // copy the enabled languages
-  this->m_LanguageEnabled = gen->m_LanguageEnabled;
-  this->m_ExtensionToLanguage = gen->m_ExtensionToLanguage;
-  this->m_IgnoreExtensions = gen->m_IgnoreExtensions;
-  this->m_LanguageToOutputExtension = gen->m_LanguageToOutputExtension;
-  this->m_LanguageToLinkerPreference = gen->m_LanguageToLinkerPreference;
-  this->m_OutputExtensions = gen->m_OutputExtensions;
+  this->LanguageEnabled = gen->LanguageEnabled;
+  this->ExtensionToLanguage = gen->ExtensionToLanguage;
+  this->IgnoreExtensions = gen->IgnoreExtensions;
+  this->LanguageToOutputExtension = gen->LanguageToOutputExtension;
+  this->LanguageToLinkerPreference = gen->LanguageToLinkerPreference;
+  this->OutputExtensions = gen->OutputExtensions;
 }
 
 //----------------------------------------------------------------------------
@@ -921,8 +921,8 @@ bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root,
 
 void cmGlobalGenerator::GetEnabledLanguages(std::vector<std::string>& lang)
 {
-  for(std::map<cmStdString, bool>::iterator i = m_LanguageEnabled.begin(); 
-      i != m_LanguageEnabled.end(); ++i)
+  for(std::map<cmStdString, bool>::iterator i = this->LanguageEnabled.begin(); 
+      i != this->LanguageEnabled.end(); ++i)
     {
     lang.push_back(i->first);
     }
@@ -930,9 +930,9 @@ void cmGlobalGenerator::GetEnabledLanguages(std::vector<std::string>& lang)
 
 const char* cmGlobalGenerator::GetLinkerPreference(const char* lang)
 {
-  if(m_LanguageToLinkerPreference.count(lang))
+  if(this->LanguageToLinkerPreference.count(lang))
     {
-    return m_LanguageToLinkerPreference[lang].c_str();
+    return this->LanguageToLinkerPreference[lang].c_str();
     }
   return "None";
 }
@@ -940,19 +940,19 @@ const char* cmGlobalGenerator::GetLinkerPreference(const char* lang)
 
 void cmGlobalGenerator::FillProjectMap()
 { 
-  m_ProjectMap.clear(); // make sure we start with a clean map
+  this->ProjectMap.clear(); // make sure we start with a clean map
   unsigned int i;
-  for(i = 0; i < m_LocalGenerators.size(); ++i)
+  for(i = 0; i < this->LocalGenerators.size(); ++i)
     {
     // for each local generator add all projects 
-    cmLocalGenerator *lg = m_LocalGenerators[i];
+    cmLocalGenerator *lg = this->LocalGenerators[i];
     std::string name;
     do 
       {
       if (name != lg->GetMakefile()->GetProjectName())
         {
         name = lg->GetMakefile()->GetProjectName();
-        m_ProjectMap[name].push_back(m_LocalGenerators[i]);
+        this->ProjectMap[name].push_back(this->LocalGenerators[i]);
         }
       lg = lg->GetParent();
       }
@@ -964,7 +964,7 @@ void cmGlobalGenerator::FillProjectMap()
 ///! Find a local generator by its startdirectory
 cmLocalGenerator* cmGlobalGenerator::FindLocalGenerator(const char* start_dir)
 {
-  std::vector<cmLocalGenerator*>* gens = &m_LocalGenerators;
+  std::vector<cmLocalGenerator*>* gens = &this->LocalGenerators;
   for(unsigned int i = 0; i < gens->size(); ++i)
     {
     std::string sd = (*gens)[i]->GetMakefile()->GetStartDirectory();
@@ -980,10 +980,10 @@ cmLocalGenerator* cmGlobalGenerator::FindLocalGenerator(const char* start_dir)
 cmTarget* cmGlobalGenerator::FindTarget(const char* project, 
                                         const char* name)
 {
-  std::vector<cmLocalGenerator*>* gens = &m_LocalGenerators;
+  std::vector<cmLocalGenerator*>* gens = &this->LocalGenerators;
   if(project)
     {
-    gens = &m_ProjectMap[project];
+    gens = &this->ProjectMap[project];
     }
   for(unsigned int i = 0; i < gens->size(); ++i)
     {
@@ -1002,17 +1002,17 @@ void cmGlobalGenerator::ConfigureRelativePaths()
   // The current working directory on Windows cannot be a network
   // path.  Therefore relative paths cannot work when the build tree
   // is a network path.
-  std::string source = m_CMakeInstance->GetHomeDirectory();
-  std::string binary = m_CMakeInstance->GetHomeOutputDirectory();
+  std::string source = this->CMakeInstance->GetHomeDirectory();
+  std::string binary = this->CMakeInstance->GetHomeOutputDirectory();
   if(binary.size() < 2 || binary.substr(0, 2) != "//")
     {
-    m_RelativePathTopSource = source;
-    m_RelativePathTopBinary = binary;
+    this->RelativePathTopSource = source;
+    this->RelativePathTopBinary = binary;
     }
   else
     {
-    m_RelativePathTopSource = "";
-    m_RelativePathTopBinary = "";
+    this->RelativePathTopSource = "";
+    this->RelativePathTopBinary = "";
     }
 }
 
@@ -1035,14 +1035,14 @@ cmGlobalGenerator::ConvertToRelativePath(const std::vector<std::string>& local,
 
   // Skip conversion if the path is not in the source or binary tree.
   std::string original = in_remote;
-  if((original.size() < m_RelativePathTopSource.size() ||
+  if((original.size() < this->RelativePathTopSource.size() ||
       !cmSystemTools::ComparePath(
-        original.substr(0, m_RelativePathTopSource.size()).c_str(),
-        m_RelativePathTopSource.c_str())) &&
-     (original.size() < m_RelativePathTopBinary.size() ||
+        original.substr(0, this->RelativePathTopSource.size()).c_str(),
+        this->RelativePathTopSource.c_str())) &&
+     (original.size() < this->RelativePathTopBinary.size() ||
       !cmSystemTools::ComparePath(
-        original.substr(0, m_RelativePathTopBinary.size()).c_str(),
-        m_RelativePathTopBinary.c_str())))
+        original.substr(0, this->RelativePathTopBinary.size()).c_str(),
+        this->RelativePathTopBinary.c_str())))
     {
     return in_remote;
     }
@@ -1129,7 +1129,7 @@ inline std::string removeQuotes(const std::string& s)
 void cmGlobalGenerator::SetupTests()
 {
   std::string ctest = 
-    m_LocalGenerators[0]->GetMakefile()->GetRequiredDefinition("CMAKE_COMMAND");
+    this->LocalGenerators[0]->GetMakefile()->GetRequiredDefinition("CMAKE_COMMAND");
   ctest = removeQuotes(ctest);
   ctest = cmSystemTools::GetFilenamePath(ctest.c_str());
   ctest += "/";
@@ -1138,7 +1138,7 @@ void cmGlobalGenerator::SetupTests()
   if(!cmSystemTools::FileExists(ctest.c_str()))
     {
     ctest =     
-      m_LocalGenerators[0]->GetMakefile()->GetRequiredDefinition("CMAKE_COMMAND");
+      this->LocalGenerators[0]->GetMakefile()->GetRequiredDefinition("CMAKE_COMMAND");
     ctest = cmSystemTools::GetFilenamePath(ctest.c_str());
     ctest += "/Debug/";
     ctest += "ctest";
@@ -1147,7 +1147,7 @@ void cmGlobalGenerator::SetupTests()
   if(!cmSystemTools::FileExists(ctest.c_str()))
     {
     ctest =     
-      m_LocalGenerators[0]->GetMakefile()->GetRequiredDefinition("CMAKE_COMMAND");
+      this->LocalGenerators[0]->GetMakefile()->GetRequiredDefinition("CMAKE_COMMAND");
     ctest = cmSystemTools::GetFilenamePath(ctest.c_str());
     ctest += "/Release/";
     ctest += "ctest";
@@ -1158,9 +1158,9 @@ void cmGlobalGenerator::SetupTests()
     {
     // Create a full path filename for output Testfile
     std::string fname;
-    fname = m_CMakeInstance->GetStartOutputDirectory();
+    fname = this->CMakeInstance->GetStartOutputDirectory();
     fname += "/";
-    if ( m_LocalGenerators[0]->GetMakefile()->IsSet("CTEST_NEW_FORMAT") )
+    if ( this->LocalGenerators[0]->GetMakefile()->IsSet("CTEST_NEW_FORMAT") )
       {
       fname += "CTestTestfile.txt";
       }
@@ -1172,9 +1172,9 @@ void cmGlobalGenerator::SetupTests()
     // Add run_test only if any tests are foun
     long total_tests = 0;
     unsigned int i;
-    for (i = 0; i < m_LocalGenerators.size(); ++i)
+    for (i = 0; i < this->LocalGenerators.size(); ++i)
       {
-      total_tests += m_LocalGenerators[i]->GetMakefile()->GetTests()->size();
+      total_tests += this->LocalGenerators[i]->GetMakefile()->GetTests()->size();
       }
 
     // If the file doesn't exist, then ENABLE_TESTING hasn't been run
@@ -1184,7 +1184,7 @@ void cmGlobalGenerator::SetupTests()
       const char* no_working_dir = 0;
       std::vector<std::string> no_depends;
       std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
-      for(it = m_ProjectMap.begin(); it!= m_ProjectMap.end(); ++it)
+      for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
         {
         std::vector<cmLocalGenerator*>& gen = it->second;
         // add the RUN_TESTS to the first local generator of each project
@@ -1205,7 +1205,7 @@ void cmGlobalGenerator::SetupTests()
 
 void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets)
 {
-  cmMakefile* mf = m_LocalGenerators[0]->GetMakefile();
+  cmMakefile* mf = this->LocalGenerators[0]->GetMakefile();
   const char* cmakeCfgIntDir = this->GetCMakeCFGInitDirectory();
   const char* cmakeCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
 
diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h
index 446899c..e6907b0 100644
--- a/Source/cmGlobalGenerator.h
+++ b/Source/cmGlobalGenerator.h
@@ -101,28 +101,30 @@ public:
                     std::string *output, 
                     const char *makeProgram, const char *config,
                     bool clean);
-  virtual std::string GenerateBuildCommand(const char* makeProgram,
-    const char *projectName, const char* additionalOptions, 
-                                           const char *targetName,
-    const char* config, bool ignoreErrors);
+  virtual std::string GenerateBuildCommand
+  (const char* makeProgram,
+   const char *projectName, const char* additionalOptions, 
+   const char *targetName,
+   const char* config, bool ignoreErrors);
+
 
   ///! Set the CMake instance
-  void SetCMakeInstance(cmake *cm) {
-    this->m_CMakeInstance = cm; };
+  void SetCMakeInstance(cmake *cm) { this->CMakeInstance = cm; };
   
   ///! Get the CMake instance
-  cmake *GetCMakeInstance() {
-    return this->m_CMakeInstance; };
+  cmake *GetCMakeInstance() { return this->CMakeInstance; };
+
+  void SetConfiguredFilesPath(const char* s){this->ConfiguredFilesPath = s;}
+  cmLocalGenerator* GetLocalGenerator(int p) { 
+    return this->LocalGenerators[p];}
+  void GetLocalGenerators(std::vector<cmLocalGenerator *>&g) { 
+    g = this->LocalGenerators;}
 
-  void SetConfiguredFilesPath(const char* s){m_ConfiguredFilesPath = s;}
-  cmLocalGenerator* GetLocalGenerator(int p) { return m_LocalGenerators[p];}
-  void GetLocalGenerators(std::vector<cmLocalGenerator *>&g) 
-    { g = m_LocalGenerators;}
   void AddLocalGenerator(cmLocalGenerator *lg);
   
   static int s_TryCompileTimeout;
   
-  bool GetForceUnixPaths() {return m_ForceUnixPaths;}
+  bool GetForceUnixPaths() {return this->ForceUnixPaths;}
   ///! return the language for the given extension
   const char* GetLanguageFromExtension(const char* ext);
   ///! is an extension to be ignored
@@ -188,31 +190,31 @@ protected:
   virtual const char* GetEditCacheTargetName()    { return 0; }
   virtual const char* GetRebuildCacheTargetName() { return 0; }
 
-  bool m_ForceUnixPaths;
-  cmStdString m_FindMakeProgramFile;
-  cmStdString m_ConfiguredFilesPath;
-  cmake *m_CMakeInstance;
-  std::vector<cmLocalGenerator *> m_LocalGenerators;
+  bool ForceUnixPaths;
+  cmStdString FindMakeProgramFile;
+  cmStdString ConfiguredFilesPath;
+  cmake *CMakeInstance;
+  std::vector<cmLocalGenerator *> LocalGenerators;
   // map from project name to vector of local generators in that project
-  std::map<cmStdString, std::vector<cmLocalGenerator*> > m_ProjectMap;
+  std::map<cmStdString, std::vector<cmLocalGenerator*> > ProjectMap;
 
 private:
   // If you add a new map here, make sure it is copied
   // in EnableLanguagesFromGenerator 
-  std::map<cmStdString, bool> m_IgnoreExtensions;
-  std::map<cmStdString, bool> m_LanguageEnabled;
-  std::map<cmStdString, cmStdString> m_OutputExtensions;
-  std::map<cmStdString, cmStdString> m_LanguageToOutputExtension;
-  std::map<cmStdString, cmStdString> m_ExtensionToLanguage;
-  std::map<cmStdString, cmStdString> m_LanguageToLinkerPreference; 
+  std::map<cmStdString, bool> IgnoreExtensions;
+  std::map<cmStdString, bool> LanguageEnabled;
+  std::map<cmStdString, cmStdString> OutputExtensions;
+  std::map<cmStdString, cmStdString> LanguageToOutputExtension;
+  std::map<cmStdString, cmStdString> ExtensionToLanguage;
+  std::map<cmStdString, cmStdString> LanguageToLinkerPreference; 
 
   // The paths to the tops of the source and binary trees used for
   // relative path computation.  A path must be either in the source
   // tree or the build tree to be converted to a relative path.  The
   // ConfigureRelativePaths method may set these to be empty when
   // using relative paths is unsafe.
-  std::string m_RelativePathTopSource;
-  std::string m_RelativePathTopBinary;
+  std::string RelativePathTopSource;
+  std::string RelativePathTopBinary;
 };
 
 #endif
diff --git a/Source/cmGlobalKdevelopGenerator.cxx b/Source/cmGlobalKdevelopGenerator.cxx
index 94b431d..5e0a46d 100644
--- a/Source/cmGlobalKdevelopGenerator.cxx
+++ b/Source/cmGlobalKdevelopGenerator.cxx
@@ -26,8 +26,8 @@
 cmGlobalKdevelopGenerator::cmGlobalKdevelopGenerator()
 {
   // This type of makefile always requires unix style paths
-  m_ForceUnixPaths = true;
-  m_FindMakeProgramFile = "CMakeUnixFindMake.cmake";
+  this->ForceUnixPaths = true;
+  this->FindMakeProgramFile = "CMakeUnixFindMake.cmake";
 }
 
 ///! Create a local generator appropriate to this Global Generator
@@ -59,7 +59,7 @@ void cmGlobalKdevelopGenerator::Generate()
   // for each sub project in the project create 
   // a kdevelop project
   std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
-  for(it = m_ProjectMap.begin(); it!= m_ProjectMap.end(); ++it)
+  for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
     {
     cmMakefile* mf = it->second[0]->GetMakefile();
     std::string outputDir=mf->GetStartOutputDirectory();
diff --git a/Source/cmGlobalMSYSMakefileGenerator.cxx b/Source/cmGlobalMSYSMakefileGenerator.cxx
index d0b9f37..8e118bd 100644
--- a/Source/cmGlobalMSYSMakefileGenerator.cxx
+++ b/Source/cmGlobalMSYSMakefileGenerator.cxx
@@ -21,8 +21,8 @@
 
 cmGlobalMSYSMakefileGenerator::cmGlobalMSYSMakefileGenerator()
 {
-  m_FindMakeProgramFile = "CMakeMSYSFindMake.cmake";
-  m_ForceUnixPaths = true;
+  this->FindMakeProgramFile = "CMakeMSYSFindMake.cmake";
+  this->ForceUnixPaths = true;
 }
 
 std::string 
@@ -73,7 +73,7 @@ void cmGlobalMSYSMakefileGenerator::EnableLanguage(std::vector<std::string>const
   mf->AddDefinition("CMAKE_GENERATOR_CC", gcc.c_str());
   mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx.c_str());
   this->cmGlobalUnixMakefileGenerator3::EnableLanguage(l, mf);
-  if(!mf->IsSet("CMAKE_AR") && !m_CMakeInstance->GetIsInTryCompile())
+  if(!mf->IsSet("CMAKE_AR") && !this->CMakeInstance->GetIsInTryCompile())
     {
     cmSystemTools::Error("CMAKE_AR was not found, please set to archive program. ",
                          mf->GetDefinition("CMAKE_AR"));
diff --git a/Source/cmGlobalMinGWMakefileGenerator.cxx b/Source/cmGlobalMinGWMakefileGenerator.cxx
index 8af608b..10da93c 100644
--- a/Source/cmGlobalMinGWMakefileGenerator.cxx
+++ b/Source/cmGlobalMinGWMakefileGenerator.cxx
@@ -20,8 +20,8 @@
 
 cmGlobalMinGWMakefileGenerator::cmGlobalMinGWMakefileGenerator()
 {
-  m_FindMakeProgramFile = "CMakeMinGWFindMake.cmake";
-  m_ForceUnixPaths = true;
+  this->FindMakeProgramFile = "CMakeMinGWFindMake.cmake";
+  this->ForceUnixPaths = true;
   
 }
 
diff --git a/Source/cmGlobalNMakeMakefileGenerator.cxx b/Source/cmGlobalNMakeMakefileGenerator.cxx
index 024aa19..f3c91eb 100644
--- a/Source/cmGlobalNMakeMakefileGenerator.cxx
+++ b/Source/cmGlobalNMakeMakefileGenerator.cxx
@@ -20,8 +20,8 @@
 
 cmGlobalNMakeMakefileGenerator::cmGlobalNMakeMakefileGenerator()
 {
-  m_FindMakeProgramFile = "CMakeNMakeFindMake.cmake";
-  m_ForceUnixPaths = false;
+  this->FindMakeProgramFile = "CMakeNMakeFindMake.cmake";
+  this->ForceUnixPaths = false;
 }
 
 void cmGlobalNMakeMakefileGenerator::EnableLanguage(std::vector<std::string>const& l,
diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx
index f9a6daa..a8b1aef 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.cxx
+++ b/Source/cmGlobalUnixMakefileGenerator3.cxx
@@ -24,8 +24,8 @@
 cmGlobalUnixMakefileGenerator3::cmGlobalUnixMakefileGenerator3()
 {
   // This type of makefile always requires unix style paths
-  m_ForceUnixPaths = true;
-  m_FindMakeProgramFile = "CMakeUnixFindMake.cmake";
+  this->ForceUnixPaths = true;
+  this->FindMakeProgramFile = "CMakeUnixFindMake.cmake";
 }
 
 void cmGlobalUnixMakefileGenerator3
@@ -124,7 +124,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
  
   // get a local generator for some useful methods
   cmLocalUnixMakefileGenerator3 *lg = 
-    static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[0]);
+    static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[0]);
     
   // Write the do not edit header.
   lg->WriteDisclaimer(makefileStream);
@@ -148,9 +148,9 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
 
   // The all and preinstall rules might never have any dependencies
   // added to them.
-  if(m_EmptyRuleHackDepends != "")
+  if(this->EmptyRuleHackDepends != "")
     {
-    depends.push_back(m_EmptyRuleHackDepends);
+    depends.push_back(this->EmptyRuleHackDepends);
     }
 
   // Write and empty all:
@@ -170,9 +170,9 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
   
   // write the target convenience rules
   unsigned int i;
-  for (i = 0; i < m_LocalGenerators.size(); ++i)
+  for (i = 0; i < this->LocalGenerators.size(); ++i)
     {
-    lg = static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[i]);
+    lg = static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
     // are any parents excluded
     bool exclude = false;
     cmLocalGenerator *lg3 = lg;
@@ -188,7 +188,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
     this->WriteConvenienceRules2(makefileStream,lg,exclude);
     }
 
-  lg = static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[0]);
+  lg = static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[0]);
   lg->WriteSpecialTargetsBottom(makefileStream);
 }
 
@@ -214,7 +214,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
   
   // get a local generator for some useful methods
   cmLocalUnixMakefileGenerator3 *lg = 
-    static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[0]);
+    static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[0]);
     
   // Write the do not edit header.
   lg->WriteDisclaimer(cmakefileStream);
@@ -226,9 +226,9 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
 
   // for each cmMakefile get its list of dependencies
   std::vector<std::string> lfiles;
-  for (unsigned int i = 0; i < m_LocalGenerators.size(); ++i)
+  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
     {
-    lg = static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[i]);
+    lg = static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
   
     // Get the list of files contributing to this generation step.
     lfiles.insert(lfiles.end(),lg->GetMakefile()->GetListFiles().begin(),
@@ -241,7 +241,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
   lfiles.erase(new_end, lfiles.end());
 
   // reset lg to the first makefile
-  lg = static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[0]);
+  lg = static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[0]);
 
   // Build the path to the cache file.
   std::string cache = this->GetCMakeInstance()->GetHomeOutputDirectory();
@@ -279,9 +279,9 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
 
   // add in all the directory information files
   std::string tmpStr;
-  for (unsigned int i = 0; i < m_LocalGenerators.size(); ++i)
+  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
     {
-    lg = static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[i]);
+    lg = static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
     tmpStr = lg->GetMakefile()->GetStartOutputDirectory();
     tmpStr += "/CMakeFiles/CMakeDirectoryInformation.cmake";
     cmakefileStream << "  \"" << 
@@ -289,7 +289,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
     }
   cmakefileStream << "  )\n\n";
 
-  this->WriteMainCMakefileLanguageRules(cmakefileStream, m_LocalGenerators);
+  this->WriteMainCMakefileLanguageRules(cmakefileStream, this->LocalGenerators);
 }
   
 void cmGlobalUnixMakefileGenerator3
@@ -383,9 +383,9 @@ cmGlobalUnixMakefileGenerator3
 
   // Work-around for makes that drop rules that have no dependencies
   // or commands.
-  if(depends.empty() && m_EmptyRuleHackDepends != "")
+  if(depends.empty() && this->EmptyRuleHackDepends != "")
     {
-    depends.push_back(m_EmptyRuleHackDepends);
+    depends.push_back(this->EmptyRuleHackDepends);
     }
 
   // Write the rule.
@@ -442,9 +442,9 @@ cmGlobalUnixMakefileGenerator3
   // write the target convenience rules
   unsigned int i;
   cmLocalUnixMakefileGenerator3 *lg;
-  for (i = 0; i < m_LocalGenerators.size(); ++i)
+  for (i = 0; i < this->LocalGenerators.size(); ++i)
     {
-    lg = static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[i]);
+    lg = static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
     // for each target Generate the rule files for each target.
     cmTargets& targets = lg->GetMakefile()->GetTargets();
     for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
@@ -636,8 +636,8 @@ cmGlobalUnixMakefileGenerator3
   // Loop over all library dependencies but not for static libs
   if (target.GetType() != cmTarget::STATIC_LIBRARY)
     {
-    const cmTarget::LinkLibraries& tlibs = target.GetLinkLibraries();
-    for(cmTarget::LinkLibraries::const_iterator lib = tlibs.begin();
+    const cmTarget::LinkLibraryVectorType& tlibs = target.GetLinkLibraries();
+    for(cmTarget::LinkLibraryVectorType::const_iterator lib = tlibs.begin();
         lib != tlibs.end(); ++lib)
       {
       // Don't emit the same library twice for this target.
@@ -683,14 +683,14 @@ cmGlobalUnixMakefileGenerator3
   if (!result)
     {
     unsigned int i;
-    for (i = 0; i < m_LocalGenerators.size(); ++i)
+    for (i = 0; i < this->LocalGenerators.size(); ++i)
       {
       // search all targets
-      result = m_LocalGenerators[i]->GetMakefile()->FindTarget(name);
+      result = this->LocalGenerators[i]->GetMakefile()->FindTarget(name);
       if (result)
         {
         lg3 = static_cast<cmLocalUnixMakefileGenerator3 *>
-          (m_LocalGenerators[i]);
+          (this->LocalGenerators[i]);
         break;
         }
       }
@@ -704,8 +704,9 @@ cmGlobalUnixMakefileGenerator3
     depends.push_back(tgtName);
     if(result->GetType() == cmTarget::STATIC_LIBRARY)
       {
-      const cmTarget::LinkLibraries& tlibs = result->GetLinkLibraries();
-      for(cmTarget::LinkLibraries::const_iterator lib = tlibs.begin();
+      const cmTarget::LinkLibraryVectorType& tlibs 
+        = result->GetLinkLibraries();
+      for(cmTarget::LinkLibraryVectorType::const_iterator lib = tlibs.begin();
           lib != tlibs.end(); ++lib)
         {
         // Don't emit the same library twice for this target.
@@ -743,9 +744,9 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule
   // for each local generator
   unsigned int i;
   cmLocalUnixMakefileGenerator3 *lg2;
-  for (i = 0; i < m_LocalGenerators.size(); ++i)
+  for (i = 0; i < this->LocalGenerators.size(); ++i)
     {
-    lg2 = static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[i]);
+    lg2 = static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
     // for the passed in makefile or if this is the top Makefile wripte out
     // the targets
     if (lg2 == lg || !lg->GetParent())
diff --git a/Source/cmGlobalUnixMakefileGenerator3.h b/Source/cmGlobalUnixMakefileGenerator3.h
index b842171..60ca2da 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.h
+++ b/Source/cmGlobalUnixMakefileGenerator3.h
@@ -136,7 +136,7 @@ protected:
   // that might not do anything but might have other dependencies
   // added later.  If non-empty this variable holds a fake dependency
   // that can be added.
-  std::string m_EmptyRuleHackDepends;
+  std::string EmptyRuleHackDepends;
 };
 
 #endif
diff --git a/Source/cmGlobalVisualStudio6Generator.cxx b/Source/cmGlobalVisualStudio6Generator.cxx
index 46c0215..d2b5b6f 100644
--- a/Source/cmGlobalVisualStudio6Generator.cxx
+++ b/Source/cmGlobalVisualStudio6Generator.cxx
@@ -21,7 +21,7 @@
 
 cmGlobalVisualStudio6Generator::cmGlobalVisualStudio6Generator()
 {
-  m_FindMakeProgramFile = "CMakeVS6FindMake.cmake";
+  this->FindMakeProgramFile = "CMakeVS6FindMake.cmake";
 }
 
 void cmGlobalVisualStudio6Generator::EnableLanguage(std::vector<std::string>const& lang,
@@ -159,7 +159,7 @@ void cmGlobalVisualStudio6Generator::Generate()
   std::vector<std::string> no_depends;
   const char* no_working_dir = 0;
   std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
-  for(it = m_ProjectMap.begin(); it!= m_ProjectMap.end(); ++it)
+  for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
     {
     std::vector<cmLocalGenerator*>& gen = it->second;
     // add the ALL_BUILD to the first local generator of each project
@@ -381,7 +381,7 @@ void cmGlobalVisualStudio6Generator::OutputDSWFile(cmLocalGenerator* root,
 void cmGlobalVisualStudio6Generator::OutputDSWFile()
 { 
   std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
-  for(it = m_ProjectMap.begin(); it!= m_ProjectMap.end(); ++it)
+  for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
     {
     this->OutputDSWFile(it->second[0], it->second);
     }
@@ -406,7 +406,7 @@ void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout,
   // insert Begin Project Dependency  Project_Dep_Name project stuff here 
   if (target.GetType() != cmTarget::STATIC_LIBRARY)
     {
-    cmTarget::LinkLibraries::const_iterator j, jend;
+    cmTarget::LinkLibraryVectorType::const_iterator j, jend;
     j = target.GetLinkLibraries().begin();
     jend = target.GetLinkLibraries().end();
     for(;j!= jend; ++j)
diff --git a/Source/cmGlobalVisualStudio71Generator.cxx b/Source/cmGlobalVisualStudio71Generator.cxx
index 9c050fa..d25785b 100644
--- a/Source/cmGlobalVisualStudio71Generator.cxx
+++ b/Source/cmGlobalVisualStudio71Generator.cxx
@@ -24,8 +24,8 @@
 
 cmGlobalVisualStudio71Generator::cmGlobalVisualStudio71Generator()
 {
-  m_FindMakeProgramFile = "CMakeVS71FindMake.cmake";
-  m_ProjectConfigurationSectionName = "ProjectConfiguration";
+  this->FindMakeProgramFile = "CMakeVS71FindMake.cmake";
+  this->ProjectConfigurationSectionName = "ProjectConfiguration";
 }
 
 
@@ -224,7 +224,7 @@ void cmGlobalVisualStudio71Generator::WriteSLNFile(std::ostream& fout,
     }
   fout << "Global\n";
   this->WriteSolutionConfigurations(fout);
-  fout << "\tGlobalSection(" << m_ProjectConfigurationSectionName
+  fout << "\tGlobalSection(" << this->ProjectConfigurationSectionName
        << ") = postSolution\n";
   // loop over again and compute the depends
   for(i = 0; i < generators.size(); ++i)
@@ -270,8 +270,8 @@ cmGlobalVisualStudio71Generator
 ::WriteSolutionConfigurations(std::ostream& fout)
 {
   fout << "\tGlobalSection(SolutionConfiguration) = preSolution\n";
-  for(std::vector<std::string>::iterator i = m_Configurations.begin();
-      i != m_Configurations.end(); ++i)
+  for(std::vector<std::string>::iterator i = this->Configurations.begin();
+      i != this->Configurations.end(); ++i)
     {
     fout << "\t\t" << *i << " = " << *i << "\n";
     }
@@ -313,7 +313,7 @@ cmGlobalVisualStudio71Generator
   // insert Begin Project Dependency  Project_Dep_Name project stuff here 
   if (target.GetType() != cmTarget::STATIC_LIBRARY)
     {
-    cmTarget::LinkLibraries::const_iterator j, jend;
+    cmTarget::LinkLibraryVectorType::const_iterator j, jend;
     j = target.GetLinkLibraries().begin();
     jend = target.GetLinkLibraries().end();
     for(;j!= jend; ++j)
@@ -321,7 +321,7 @@ cmGlobalVisualStudio71Generator
       if(j->first != dspname)
         {
         // is the library part of this SLN ? If so add dependency
-        if(this->FindTarget(m_CurrentProject.c_str(), j->first.c_str()))
+        if(this->FindTarget(this->CurrentProject.c_str(), j->first.c_str()))
           {
           fout << "\t\t{" << this->GetGUID(j->first.c_str()) << "} = {"
                << this->GetGUID(j->first.c_str()) << "}\n";
@@ -414,8 +414,8 @@ cmGlobalVisualStudio71Generator::WriteProjectConfigurations(std::ostream& fout,
                                                            bool in_all_build)
 {
   std::string guid = this->GetGUID(name);
-  for(std::vector<std::string>::iterator i = m_Configurations.begin();
-      i != m_Configurations.end(); ++i)
+  for(std::vector<std::string>::iterator i = this->Configurations.begin();
+      i != this->Configurations.end(); ++i)
     {
     fout << "\t\t{" << guid << "}." << *i << ".ActiveCfg = " << *i << "|Win32\n";
     if (in_all_build)
diff --git a/Source/cmGlobalVisualStudio71Generator.h b/Source/cmGlobalVisualStudio71Generator.h
index e647ecd..976758c 100644
--- a/Source/cmGlobalVisualStudio71Generator.h
+++ b/Source/cmGlobalVisualStudio71Generator.h
@@ -60,6 +60,6 @@ protected:
   virtual void WriteSLNFooter(std::ostream& fout);
   virtual void WriteSLNHeader(std::ostream& fout);
 
-  std::string m_ProjectConfigurationSectionName;
+  std::string ProjectConfigurationSectionName;
 };
 #endif
diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx
index 85ea04c..ff67fd0 100644
--- a/Source/cmGlobalVisualStudio7Generator.cxx
+++ b/Source/cmGlobalVisualStudio7Generator.cxx
@@ -24,7 +24,7 @@
 
 cmGlobalVisualStudio7Generator::cmGlobalVisualStudio7Generator()
 {
-  m_FindMakeProgramFile = "CMakeVS7FindMake.cmake";
+  this->FindMakeProgramFile = "CMakeVS7FindMake.cmake";
 }
 
 
@@ -120,7 +120,7 @@ void cmGlobalVisualStudio7Generator::GenerateConfigurations(cmMakefile* mf)
 {
   // process the configurations
   const char* ct 
-    = m_CMakeInstance->GetCacheDefinition("CMAKE_CONFIGURATION_TYPES");
+    = this->CMakeInstance->GetCacheDefinition("CMAKE_CONFIGURATION_TYPES");
   if ( ct )
     {
     std::string configTypes = ct;
@@ -145,10 +145,10 @@ void cmGlobalVisualStudio7Generator::GenerateConfigurations(cmMakefile* mf)
          config == "MinSizeRel" || config == "RelWithDebInfo")
         {
         // only add unique configurations
-        if(std::find(m_Configurations.begin(),
-                     m_Configurations.end(), config) == m_Configurations.end())
+        if(std::find(this->Configurations.begin(),
+                     this->Configurations.end(), config) == this->Configurations.end())
           {
-          m_Configurations.push_back(config);
+          this->Configurations.push_back(config);
           }
         }
       else
@@ -161,18 +161,18 @@ void cmGlobalVisualStudio7Generator::GenerateConfigurations(cmMakefile* mf)
       start = endpos+1;
       }
     }
-  if(m_Configurations.size() == 0)
+  if(this->Configurations.size() == 0)
     {
-    m_Configurations.push_back("Debug");
-    m_Configurations.push_back("Release");
+    this->Configurations.push_back("Debug");
+    this->Configurations.push_back("Release");
     }
   
   // Reset the entry to have a semi-colon separated list.
-  std::string configs = m_Configurations[0];
-  for(unsigned int i=1; i < m_Configurations.size(); ++i)
+  std::string configs = this->Configurations[0];
+  for(unsigned int i=1; i < this->Configurations.size(); ++i)
     {
     configs += ";";
-    configs += m_Configurations[i];
+    configs += this->Configurations[i];
     }
   
   mf->AddCacheDefinition(
@@ -192,7 +192,7 @@ void cmGlobalVisualStudio7Generator::Generate()
   const char* no_working_dir = 0;
   std::vector<std::string> no_depends;
   std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
-  for(it = m_ProjectMap.begin(); it!= m_ProjectMap.end(); ++it)
+  for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
     {
     std::vector<cmLocalGenerator*>& gen = it->second;
     // add the ALL_BUILD to the first local generator of each project
@@ -203,7 +203,8 @@ void cmGlobalVisualStudio7Generator::Generate()
                           no_working_dir,
                           "echo", "Build all projects");
       std::string cmake_command = 
-        m_LocalGenerators[0]->GetMakefile()->GetRequiredDefinition("CMAKE_COMMAND");
+        this->LocalGenerators[0]->GetMakefile()->
+        GetRequiredDefinition("CMAKE_COMMAND");
       }
     }
 
@@ -224,7 +225,7 @@ void cmGlobalVisualStudio7Generator::OutputSLNFile(cmLocalGenerator* root,
     {
     return;
     }
-  m_CurrentProject = root->GetMakefile()->GetProjectName();
+  this->CurrentProject = root->GetMakefile()->GetProjectName();
   std::string fname = root->GetMakefile()->GetStartOutputDirectory();
   fname += "/";
   fname += root->GetMakefile()->GetProjectName();
@@ -242,7 +243,7 @@ void cmGlobalVisualStudio7Generator::OutputSLNFile(cmLocalGenerator* root,
 void cmGlobalVisualStudio7Generator::OutputSLNFile()
 { 
   std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
-  for(it = m_ProjectMap.begin(); it!= m_ProjectMap.end(); ++it)
+  for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
     {
     this->OutputSLNFile(it->second[0], it->second);
     }
@@ -422,8 +423,8 @@ void cmGlobalVisualStudio7Generator::WriteSLNFile(std::ostream& fout,
        << "\tGlobalSection(SolutionConfiguration) = preSolution\n";
   
   int c = 0;
-  for(std::vector<std::string>::iterator i = m_Configurations.begin();
-      i != m_Configurations.end(); ++i)
+  for(std::vector<std::string>::iterator i = this->Configurations.begin();
+      i != this->Configurations.end(); ++i)
     {
     fout << "\t\tConfigName." << c << " = " << *i << "\n";
     c++;
@@ -551,7 +552,7 @@ cmGlobalVisualStudio7Generator
   // insert Begin Project Dependency  Project_Dep_Name project stuff here 
   if (target.GetType() != cmTarget::STATIC_LIBRARY)
     {
-    cmTarget::LinkLibraries::const_iterator j, jend;
+    cmTarget::LinkLibraryVectorType::const_iterator j, jend;
     j = target.GetLinkLibraries().begin();
     jend = target.GetLinkLibraries().end();
     for(;j!= jend; ++j)
@@ -559,7 +560,7 @@ cmGlobalVisualStudio7Generator
       if(j->first != dspname)
         {
         // is the library part of this SLN ? If so add dependency
-        if(this->FindTarget(m_CurrentProject.c_str(), j->first.c_str()))
+        if(this->FindTarget(this->CurrentProject.c_str(), j->first.c_str()))
           {
           std::string guid = this->GetGUID(j->first.c_str());
           if(guid.size() == 0)
@@ -624,8 +625,8 @@ cmGlobalVisualStudio7Generator::WriteProjectConfigurations(std::ostream& fout,
                                                            bool in_all_build)
 {
   std::string guid = this->GetGUID(name);
-  for(std::vector<std::string>::iterator i = m_Configurations.begin();
-      i != m_Configurations.end(); ++i)
+  for(std::vector<std::string>::iterator i = this->Configurations.begin();
+      i != this->Configurations.end(); ++i)
     {
     fout << "\t\t{" << guid << "}." << *i << ".ActiveCfg = " << *i << "|Win32\n";
     if (in_all_build)
@@ -677,7 +678,7 @@ std::string cmGlobalVisualStudio7Generator::GetGUID(const char* name)
 {
   std::string guidStoreName = name;
   guidStoreName += "_GUID_CMAKE";
-  const char* storedGUID = m_CMakeInstance->GetCacheDefinition(guidStoreName.c_str());
+  const char* storedGUID = this->CMakeInstance->GetCacheDefinition(guidStoreName.c_str());
   if(storedGUID)
     {
     return std::string(storedGUID);
@@ -692,7 +693,7 @@ void cmGlobalVisualStudio7Generator::CreateGUID(const char* name)
 {
   std::string guidStoreName = name;
   guidStoreName += "_GUID_CMAKE";
-  if(m_CMakeInstance->GetCacheDefinition(guidStoreName.c_str()))
+  if(this->CMakeInstance->GetCacheDefinition(guidStoreName.c_str()))
     {
     return;
     }
@@ -704,13 +705,13 @@ void cmGlobalVisualStudio7Generator::CreateGUID(const char* name)
   ret = reinterpret_cast<char*>(uidstr);
   RpcStringFree(&uidstr);
   ret = cmSystemTools::UpperCase(ret);
-  m_CMakeInstance->AddCacheEntry(guidStoreName.c_str(), ret.c_str(), "Stored GUID", 
+  this->CMakeInstance->AddCacheEntry(guidStoreName.c_str(), ret.c_str(), "Stored GUID", 
                                  cmCacheManager::INTERNAL);
 }
 
 std::vector<std::string> *cmGlobalVisualStudio7Generator::GetConfigurations()
 {
-  return &m_Configurations;
+  return &this->Configurations;
 };
 
 //----------------------------------------------------------------------------
diff --git a/Source/cmGlobalVisualStudio7Generator.h b/Source/cmGlobalVisualStudio7Generator.h
index 88b603a..59588ce 100644
--- a/Source/cmGlobalVisualStudio7Generator.h
+++ b/Source/cmGlobalVisualStudio7Generator.h
@@ -115,12 +115,12 @@ protected:
                             const std::vector<std::string>& dependencies);
 
 
-  std::vector<std::string> m_Configurations;
-  std::map<cmStdString, cmStdString> m_GUIDMap;
+  std::vector<std::string> Configurations;
+  std::map<cmStdString, cmStdString> GUIDMap;
 
   // Set during OutputSLNFile with the name of the current project.
   // There is one SLN file per project.
-  std::string m_CurrentProject;
+  std::string CurrentProject;
 };
 
 #define CMAKE_CHECK_BUILD_SYSTEM_TARGET "ZERO_CHECK"
diff --git a/Source/cmGlobalVisualStudio8Generator.cxx b/Source/cmGlobalVisualStudio8Generator.cxx
index bbd5138..cbc7822 100644
--- a/Source/cmGlobalVisualStudio8Generator.cxx
+++ b/Source/cmGlobalVisualStudio8Generator.cxx
@@ -24,8 +24,8 @@
 
 cmGlobalVisualStudio8Generator::cmGlobalVisualStudio8Generator()
 {
-  m_FindMakeProgramFile = "CMakeVS8FindMake.cmake";
-  m_ProjectConfigurationSectionName = "ProjectConfigurationPlatforms";
+  this->FindMakeProgramFile = "CMakeVS8FindMake.cmake";
+  this->ProjectConfigurationSectionName = "ProjectConfigurationPlatforms";
 }
 
 
@@ -71,7 +71,7 @@ void cmGlobalVisualStudio8Generator::Generate()
   const char* no_working_directory = 0;
   std::vector<std::string> no_depends;
   std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
-  for(it = m_ProjectMap.begin(); it!= m_ProjectMap.end(); ++it)
+  for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
     {
     std::vector<cmLocalGenerator*>& generators = it->second;
     if(!generators.empty())
@@ -203,8 +203,8 @@ cmGlobalVisualStudio8Generator
 ::WriteSolutionConfigurations(std::ostream& fout)
 {
   fout << "\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\n";
-  for(std::vector<std::string>::iterator i = m_Configurations.begin();
-      i != m_Configurations.end(); ++i)
+  for(std::vector<std::string>::iterator i = this->Configurations.begin();
+      i != this->Configurations.end(); ++i)
     {
     fout << "\t\t" << *i << "|Win32 = " << *i << "|Win32\n";
     }
@@ -218,8 +218,8 @@ cmGlobalVisualStudio8Generator
                              const char* name, bool in_all_build)
 {
   std::string guid = this->GetGUID(name);
-  for(std::vector<std::string>::iterator i = m_Configurations.begin();
-      i != m_Configurations.end(); ++i)
+  for(std::vector<std::string>::iterator i = this->Configurations.begin();
+      i != this->Configurations.end(); ++i)
     {
     fout << "\t\t{" << guid << "}." << *i << "|Win32.ActiveCfg = " << *i << "|Win32\n";
     if (in_all_build)
diff --git a/Source/cmGlobalWatcomWMakeGenerator.cxx b/Source/cmGlobalWatcomWMakeGenerator.cxx
index 434d217..81ca741 100644
--- a/Source/cmGlobalWatcomWMakeGenerator.cxx
+++ b/Source/cmGlobalWatcomWMakeGenerator.cxx
@@ -20,8 +20,8 @@
 
 cmGlobalWatcomWMakeGenerator::cmGlobalWatcomWMakeGenerator()
 {
-  m_FindMakeProgramFile = "CMakeFindWMake.cmake";
-  m_ForceUnixPaths = false;
+  this->FindMakeProgramFile = "CMakeFindWMake.cmake";
+  this->ForceUnixPaths = false;
 }
 
 void cmGlobalWatcomWMakeGenerator::EnableLanguage(std::vector<std::string>const& l,
diff --git a/Source/cmGlobalXCode21Generator.cxx b/Source/cmGlobalXCode21Generator.cxx
index 7948e06..f8a50c1 100644
--- a/Source/cmGlobalXCode21Generator.cxx
+++ b/Source/cmGlobalXCode21Generator.cxx
@@ -19,7 +19,7 @@
 
 cmGlobalXCode21Generator::cmGlobalXCode21Generator()
 {
-  this->m_XcodeVersion = 21;
+  this->this->XcodeVersion = 21;
 }
 
 //----------------------------------------------------------------------------
@@ -38,8 +38,8 @@ cmGlobalXCode21Generator::WriteXCodePBXProj(std::ostream& fout,
   fout << "};\n";
   cmXCode21Object::Indent(1, fout);
   fout << "objectVersion = 42;\n";
-  cmXCode21Object::PrintList(m_XCodeObjects, fout);
+  cmXCode21Object::PrintList(this->XCodeObjects, fout);
   cmXCode21Object::Indent(1, fout);
-  fout << "rootObject = " << m_RootObject->GetId() << " /* Project object */;\n";
+  fout << "rootObject = " << this->RootObject->GetId() << " /* Project object */;\n";
   fout << "}\n";
 }
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index b33b459..057c453 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -35,29 +35,29 @@ class cmXcodeVersionParser : public cmXMLParser
 public:
   void StartElement(const char* , const char** )
     {
-      m_Data = "";
+      this->Data = "";
     }
   void EndElement(const char* name)
     {
       if(strcmp(name, "key") == 0)
         {
-        m_Key = m_Data;
+        this->Key = this->Data;
         }
       else if(strcmp(name, "string") == 0)
         {
-        if(m_Key == "CFBundleShortVersionString")
+        if(this->Key == "CFBundleShortVersionString")
           {
-          m_Version = (int)(10.0 * atof(m_Data.c_str()));
+          this->Version = (int)(10.0 * atof(this->Data.c_str()));
           }
         }
     }
   void CharacterDataHandler(const char* data, int length)
     {
-      m_Data.append(data, length);
+      this->Data.append(data, length);
     }
-  int m_Version;
-  std::string m_Key;
-  std::string m_Data;
+  int this->Version;
+  std::string this->Key;
+  std::string this->Data;
 };
 #endif
 
@@ -68,13 +68,13 @@ public:
 //----------------------------------------------------------------------------
 cmGlobalXCodeGenerator::cmGlobalXCodeGenerator()
 {
-  m_FindMakeProgramFile = "CMakeFindXCode.cmake";
-  m_RootObject = 0;
-  m_MainGroupChildren = 0;
-  m_SourcesGroupChildren = 0;
-  m_CurrentMakefile = 0;
-  m_CurrentLocalGenerator = 0;
-  m_XcodeVersion = 15;
+  this->FindMakeProgramFile = "CMakeFindXCode.cmake";
+  this->RootObject = 0;
+  this->MainGroupChildren = 0;
+  this->SourcesGroupChildren = 0;
+  this->CurrentMakefile = 0;
+  this->CurrentLocalGenerator = 0;
+  this->XcodeVersion = 15;
 }
 
 //----------------------------------------------------------------------------
@@ -83,18 +83,18 @@ cmGlobalGenerator* cmGlobalXCodeGenerator::New()
 #if defined(CMAKE_BUILD_WITH_CMAKE)  
   cmXcodeVersionParser parser;
   parser.ParseFile("/Developer/Applications/Xcode.app/Contents/version.plist");
-  if(parser.m_Version == 15)
+  if(parser.Version == 15)
     {
     return new cmGlobalXCodeGenerator;
     }
-  else if (parser.m_Version == 20)
+  else if (parser.Version == 20)
     {
     cmSystemTools::Message("Xcode 2.0 not really supported by cmake, "
                            "using Xcode 15 generator\n");
     return new cmGlobalXCodeGenerator;
     }
   cmGlobalXCodeGenerator* ret = new cmGlobalXCode21Generator;
-  ret->SetVersion(parser.m_Version);
+  ret->SetVersion(parser.Version);
   return ret;
 #else
   std::cerr 
@@ -109,7 +109,7 @@ void cmGlobalXCodeGenerator::EnableLanguage(std::vector<std::string>const&
                                             cmMakefile * mf)
 { 
   mf->AddDefinition("XCODE","1");
-  if(m_XcodeVersion == 15)
+  if(this->XcodeVersion == 15)
     {
     }
   else
@@ -151,7 +151,7 @@ std::string cmGlobalXCodeGenerator::GenerateBuildCommand(const char* makeProgram
   makeCommand += " -project ";
   makeCommand += projectName;
   makeCommand += ".xcode";
-  if(m_XcodeVersion > 20)
+  if(this->XcodeVersion > 20)
     {
     makeCommand += "proj";
     }
@@ -179,7 +179,7 @@ std::string cmGlobalXCodeGenerator::GenerateBuildCommand(const char* makeProgram
     {
     makeCommand += "ALL_BUILD";
     }
-  if(m_XcodeVersion == 15)
+  if(this->XcodeVersion == 15)
     {
     makeCommand += " -buildstyle Development ";
     }
@@ -201,39 +201,39 @@ std::string cmGlobalXCodeGenerator::GenerateBuildCommand(const char* makeProgram
 void cmGlobalXCodeGenerator::ConfigureOutputPaths()
 {
   // Format the library and executable output paths.
-  m_LibraryOutputPath = 
-    m_CurrentMakefile->GetSafeDefinition("LIBRARY_OUTPUT_PATH");
-  if(m_LibraryOutputPath.size() == 0)
+  this->LibraryOutputPath = 
+    this->CurrentMakefile->GetSafeDefinition("LIBRARY_OUTPUT_PATH");
+  if(this->LibraryOutputPath.size() == 0)
     {
-    m_LibraryOutputPath = m_CurrentMakefile->GetCurrentOutputDirectory();
+    this->LibraryOutputPath = this->CurrentMakefile->GetCurrentOutputDirectory();
     }
   // make sure there is a trailing slash
-  if(m_LibraryOutputPath.size() && 
-     m_LibraryOutputPath[m_LibraryOutputPath.size()-1] != '/')
+  if(this->LibraryOutputPath.size() && 
+     this->LibraryOutputPath[this->LibraryOutputPath.size()-1] != '/')
     {
-    m_LibraryOutputPath += "/";
-    if(!cmSystemTools::MakeDirectory(m_LibraryOutputPath.c_str()))
+    this->LibraryOutputPath += "/";
+    if(!cmSystemTools::MakeDirectory(this->LibraryOutputPath.c_str()))
       {
       cmSystemTools::Error("Error creating directory ",
-                           m_LibraryOutputPath.c_str());
+                           this->LibraryOutputPath.c_str());
       }
     }
-  m_CurrentMakefile->AddLinkDirectory(m_LibraryOutputPath.c_str());
-  m_ExecutableOutputPath = 
-    m_CurrentMakefile->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
-  if(m_ExecutableOutputPath.size() == 0)
+  this->CurrentMakefile->AddLinkDirectory(this->LibraryOutputPath.c_str());
+  this->ExecutableOutputPath = 
+    this->CurrentMakefile->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
+  if(this->ExecutableOutputPath.size() == 0)
     {
-    m_ExecutableOutputPath = m_CurrentMakefile->GetCurrentOutputDirectory();
+    this->ExecutableOutputPath = this->CurrentMakefile->GetCurrentOutputDirectory();
     }
   // make sure there is a trailing slash
-  if(m_ExecutableOutputPath.size() && 
-     m_ExecutableOutputPath[m_ExecutableOutputPath.size()-1] != '/')
+  if(this->ExecutableOutputPath.size() && 
+     this->ExecutableOutputPath[this->ExecutableOutputPath.size()-1] != '/')
     {
-    m_ExecutableOutputPath += "/";
-    if(!cmSystemTools::MakeDirectory(m_ExecutableOutputPath.c_str()))
+    this->ExecutableOutputPath += "/";
+    if(!cmSystemTools::MakeDirectory(this->ExecutableOutputPath.c_str()))
       {
       cmSystemTools::Error("Error creating directory ",
-                           m_ExecutableOutputPath.c_str());
+                           this->ExecutableOutputPath.c_str());
       }
     }
 }
@@ -252,16 +252,16 @@ void cmGlobalXCodeGenerator::Generate()
 {
   this->cmGlobalGenerator::Generate();
   std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
-  for(it = m_ProjectMap.begin(); it!= m_ProjectMap.end(); ++it)
+  for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
     { 
     cmLocalGenerator* root = it->second[0];
-    m_CurrentProject = root->GetMakefile()->GetProjectName();
+    this->CurrentProject = root->GetMakefile()->GetProjectName();
     this->SetCurrentLocalGenerator(root);
-    m_OutputDir = m_CurrentMakefile->GetHomeOutputDirectory();
-    m_OutputDir = cmSystemTools::CollapseFullPath(m_OutputDir.c_str());
-    cmSystemTools::SplitPath(m_OutputDir.c_str(),
-                             m_ProjectOutputDirectoryComponents);
-    m_CurrentLocalGenerator = root;
+    this->OutputDir = this->CurrentMakefile->GetHomeOutputDirectory();
+    this->OutputDir = cmSystemTools::CollapseFullPath(this->OutputDir.c_str());
+    cmSystemTools::SplitPath(this->OutputDir.c_str(),
+                             this->ProjectOutputDirectoryComponents);
+    this->CurrentLocalGenerator = root;
     // add ALL_BUILD, INSTALL, etc
     this->AddExtraTargets(root, it->second);
     // now create the project
@@ -286,17 +286,17 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
   
   // Add XCODE depend helper 
   std::string dir = mf->GetCurrentOutputDirectory();
-  m_CurrentXCodeHackMakefile = dir;
-  m_CurrentXCodeHackMakefile += "/CMakeScripts";
-  cmSystemTools::MakeDirectory(m_CurrentXCodeHackMakefile.c_str());
-  m_CurrentXCodeHackMakefile += "/XCODE_DEPEND_HELPER.make";
+  this->CurrentXCodeHackMakefile = dir;
+  this->CurrentXCodeHackMakefile += "/CMakeScripts";
+  cmSystemTools::MakeDirectory(this->CurrentXCodeHackMakefile.c_str());
+  this->CurrentXCodeHackMakefile += "/XCODE_DEPEND_HELPER.make";
   cmCustomCommandLine makecommand;
   makecommand.push_back("make");
   makecommand.push_back("-C");
   makecommand.push_back(dir.c_str());
   makecommand.push_back("-f");
-  makecommand.push_back(m_CurrentXCodeHackMakefile.c_str());
-  if(m_XcodeVersion > 20)
+  makecommand.push_back(this->CurrentXCodeHackMakefile.c_str());
+  if(this->XcodeVersion > 20)
     {
     makecommand.push_back("all.$(CONFIGURATION)");
     }
@@ -352,11 +352,11 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile(cmLocalGenerator* root)
     std::unique(lfiles.begin(), lfiles.end());
   lfiles.erase(new_end, lfiles.end());
   std::string dir = mf->GetHomeOutputDirectory();
-  m_CurrentReRunCMakeMakefile = dir;
-  m_CurrentReRunCMakeMakefile += "/CMakeScripts";
-  cmSystemTools::MakeDirectory(m_CurrentReRunCMakeMakefile.c_str());
-  m_CurrentReRunCMakeMakefile += "/ReRunCMake.make";
-  cmGeneratedFileStream makefileStream(m_CurrentReRunCMakeMakefile.c_str());
+  this->CurrentReRunCMakeMakefile = dir;
+  this->CurrentReRunCMakeMakefile += "/CMakeScripts";
+  cmSystemTools::MakeDirectory(this->CurrentReRunCMakeMakefile.c_str());
+  this->CurrentReRunCMakeMakefile += "/ReRunCMake.make";
+  cmGeneratedFileStream makefileStream(this->CurrentReRunCMakeMakefile.c_str());
   makefileStream.SetCopyIfDifferent(true);
   makefileStream << "# Generated by CMake, DO NOT EDIT\n";
   makefileStream << "CMakeFiles/cmake.check_cache: ";
@@ -376,15 +376,15 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile(cmLocalGenerator* root)
 //----------------------------------------------------------------------------
 void cmGlobalXCodeGenerator::ClearXCodeObjects()
 {
-  m_TargetDoneSet.clear();
-  for(unsigned int i = 0; i < m_XCodeObjects.size(); ++i)
+  this->TargetDoneSet.clear();
+  for(unsigned int i = 0; i < this->XCodeObjects.size(); ++i)
     {
-    delete m_XCodeObjects[i];
+    delete this->XCodeObjects[i];
     }
-  m_XCodeObjects.clear();
-  m_GroupMap.clear();
-  m_GroupNameMap.clear();
-  m_TargetGroup.clear();
+  this->XCodeObjects.clear();
+  this->GroupMap.clear();
+  this->GroupNameMap.clear();
+  this->TargetGroup.clear();
 }
 
 //----------------------------------------------------------------------------
@@ -392,7 +392,7 @@ cmXCodeObject*
 cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::PBXType ptype)
 {
   cmXCodeObject* obj;
-  if(m_XcodeVersion == 15)
+  if(this->XcodeVersion == 15)
     {
     obj = new cmXCodeObject(ptype, cmXCodeObject::OBJECT);
     }
@@ -400,7 +400,7 @@ cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::PBXType ptype)
     {
     obj = new cmXCode21Object(ptype, cmXCodeObject::OBJECT);
     }
-  m_XCodeObjects.push_back(obj);
+  this->XCodeObjects.push_back(obj);
   return obj;
 }
 
@@ -409,7 +409,7 @@ cmXCodeObject*
 cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::Type type)
 {
   cmXCodeObject* obj = new cmXCodeObject(cmXCodeObject::None, type);
-  m_XCodeObjects.push_back(obj);
+  this->XCodeObjects.push_back(obj);
   return obj;
 }
 
@@ -445,7 +445,7 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg,
   lg->AppendFlags(flags, sf->GetProperty("COMPILE_FLAGS"));
   cmXCodeObject* fileRef = this->CreateObject(cmXCodeObject::PBXFileReference);
 
-  cmXCodeObject* group = m_GroupMap[sf];
+  cmXCodeObject* group = this->GroupMap[sf];
   cmXCodeObject* children = group->GetObject("children");
   children->AddObject(fileRef);
   cmXCodeObject* buildFile = this->CreateObject(cmXCodeObject::PBXBuildFile);
@@ -510,7 +510,7 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg,
   
   fileRef->AddAttribute("name", this->CreateString(file.c_str()));
   fileRef->AddAttribute("path", this->CreateString(path.c_str()));
-  if(m_XcodeVersion == 15)
+  if(this->XcodeVersion == 15)
     {
     fileRef->AddAttribute("refType", this->CreateString("4"));
     }
@@ -531,11 +531,11 @@ bool cmGlobalXCodeGenerator::SpecialTargetEmitted(std::string const& tname)
   if(tname == "ALL_BUILD" || tname == "XCODE_DEPEND_HELPER" ||
      tname == "install" || tname == "RUN_TESTS" )
     {
-    if(m_TargetDoneSet.find(tname) != m_TargetDoneSet.end())
+    if(this->TargetDoneSet.find(tname) != this->TargetDoneSet.end())
       {
       return true;
       }
-    m_TargetDoneSet.insert(tname);
+    this->TargetDoneSet.insert(tname);
     return false;
     }
   return false;
@@ -544,33 +544,33 @@ bool cmGlobalXCodeGenerator::SpecialTargetEmitted(std::string const& tname)
 
 void cmGlobalXCodeGenerator::SetCurrentLocalGenerator(cmLocalGenerator* gen)
 {
-  m_CurrentLocalGenerator = gen;
-  m_CurrentMakefile = gen->GetMakefile();
+  this->CurrentLocalGenerator = gen;
+  this->CurrentMakefile = gen->GetMakefile();
   std::string outdir =
-    cmSystemTools::CollapseFullPath(m_CurrentMakefile->
+    cmSystemTools::CollapseFullPath(this->CurrentMakefile->
                                     GetCurrentOutputDirectory());
-  cmSystemTools::SplitPath(outdir.c_str(), m_CurrentOutputDirectoryComponents);
+  cmSystemTools::SplitPath(outdir.c_str(), this->CurrentOutputDirectoryComponents);
 
   // Select the current set of configuration types.
-  m_CurrentConfigurationTypes.clear();
-  if(m_XcodeVersion > 20)
+  this->CurrentConfigurationTypes.clear();
+  if(this->XcodeVersion > 20)
     {
     if(const char* types =
-       m_CurrentMakefile->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
+       this->CurrentMakefile->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
       {
-      cmSystemTools::ExpandListArgument(types, m_CurrentConfigurationTypes);
+      cmSystemTools::ExpandListArgument(types, this->CurrentConfigurationTypes);
       }
     }
-  if(m_CurrentConfigurationTypes.empty())
+  if(this->CurrentConfigurationTypes.empty())
     {
     if(const char* buildType =
-       m_CurrentMakefile->GetDefinition("CMAKE_BUILD_TYPE"))
+       this->CurrentMakefile->GetDefinition("CMAKE_BUILD_TYPE"))
       {
-      m_CurrentConfigurationTypes.push_back(buildType);
+      this->CurrentConfigurationTypes.push_back(buildType);
       }
     else
       {
-      m_CurrentConfigurationTypes.push_back("");
+      this->CurrentConfigurationTypes.push_back("");
       }
     }
 }
@@ -583,7 +583,7 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
                                            targets)
 {
   this->SetCurrentLocalGenerator(gen);
-  cmTargets &tgts = m_CurrentMakefile->GetTargets();
+  cmTargets &tgts = this->CurrentMakefile->GetTargets();
   for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
     { 
     cmTarget& cmtarget = l->second;
@@ -623,7 +623,7 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
         i != classes.end(); ++i)
       {
       cmXCodeObject* xsf =
-        this->CreateXCodeSourceFile(m_CurrentLocalGenerator, *i, cmtarget);
+        this->CreateXCodeSourceFile(this->CurrentLocalGenerator, *i, cmtarget);
       cmXCodeObject* fr = xsf->GetObject("fileRef");
       cmXCodeObject* filetype = 
         fr->GetObject()->GetObject("lastKnownFileType");
@@ -823,20 +823,20 @@ cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase,
 {
   if(strcmp(name, "cmakeReRunPhase") == 0)
     {
-    std::string cdir = m_CurrentMakefile->GetHomeOutputDirectory();
+    std::string cdir = this->CurrentMakefile->GetHomeOutputDirectory();
     cdir = this->ConvertToRelativeForMake(cdir.c_str());
     std::string makecmd = "make -C ";
     makecmd += cdir;
     makecmd += " -f ";
     makecmd += 
-      this->ConvertToRelativeForMake(m_CurrentReRunCMakeMakefile.c_str());
+      this->ConvertToRelativeForMake(this->CurrentReRunCMakeMakefile.c_str());
     cmSystemTools::ReplaceString(makecmd, "\\ ", "\\\\ ");
     buildphase->AddAttribute("shellScript",
                              this->CreateString(makecmd.c_str()));
     return;
     }
   
-  std::string dir = m_CurrentMakefile->GetCurrentOutputDirectory();
+  std::string dir = this->CurrentMakefile->GetCurrentOutputDirectory();
   dir += "/CMakeScripts";
   cmSystemTools::MakeDirectory(dir.c_str());
   std::string makefile = dir;
@@ -900,7 +900,7 @@ cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase,
       for(std::vector<std::string>::const_iterator d = cc.GetDepends().begin();
           d != cc.GetDepends().end(); ++d)
         {
-        if(!this->FindTarget(m_CurrentProject.c_str(),
+        if(!this->FindTarget(this->CurrentProject.c_str(),
                              d->c_str()))
           {
           // if the depend is not a target but
@@ -949,7 +949,7 @@ cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase,
         }
       }
     }
-  std::string cdir = m_CurrentMakefile->GetCurrentOutputDirectory();
+  std::string cdir = this->CurrentMakefile->GetCurrentOutputDirectory();
   cdir = this->ConvertToRelativeForXCode(cdir.c_str());
   std::string makecmd = "make -C ";
   makecmd += cdir;
@@ -976,9 +976,9 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
   if(shared)
     {
     defFlags += "-D";
-    if(const char* custom_export_name = target.GetProperty("DEFINE_SYMBOL"))
+    if(const char* custothis->export_name = target.GetProperty("DEFINE_SYMBOL"))
       {
-      defFlags += custom_export_name;
+      defFlags += custothis->export_name;
       }
     else
       {
@@ -994,24 +994,24 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
     // for c++ projects get the c flags as well
     if(strcmp(lang, "CXX") == 0)
       {
-      m_CurrentLocalGenerator->AddLanguageFlags(cflags, "C", configName);
-      m_CurrentLocalGenerator->AddSharedFlags(cflags, lang, shared);
+      this->CurrentLocalGenerator->AddLanguageFlags(cflags, "C", configName);
+      this->CurrentLocalGenerator->AddSharedFlags(cflags, lang, shared);
       }
 
     // Add language-specific flags.
-    m_CurrentLocalGenerator->AddLanguageFlags(flags, lang, configName);
+    this->CurrentLocalGenerator->AddLanguageFlags(flags, lang, configName);
     
     // Add shared-library flags if needed.
-    m_CurrentLocalGenerator->AddSharedFlags(flags, lang, shared);
+    this->CurrentLocalGenerator->AddSharedFlags(flags, lang, shared);
     }
 
   // Add define flags
-  m_CurrentLocalGenerator->AppendFlags(defFlags,
-                                       m_CurrentMakefile->GetDefineFlags());
+  this->CurrentLocalGenerator->AppendFlags(defFlags,
+                                       this->CurrentMakefile->GetDefineFlags());
   cmSystemTools::ReplaceString(defFlags, "\"", "\\\"");
   cmSystemTools::ReplaceString(flags, "\"", "\\\"");
   cmSystemTools::ReplaceString(cflags, "\"", "\\\"");
-  if(m_XcodeVersion > 15)
+  if(this->XcodeVersion > 15)
     {
     buildSettings->
       AddAttribute("GCC_PREPROCESSOR_DEFINITIONS", 
@@ -1022,17 +1022,17 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
   if(target.GetType() == cmTarget::EXECUTABLE)
     {
     extraLinkOptions = 
-      m_CurrentMakefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS");
+      this->CurrentMakefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS");
     }
   if(target.GetType() == cmTarget::SHARED_LIBRARY)
     {
     extraLinkOptions = 
-      m_CurrentMakefile->GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS");
+      this->CurrentMakefile->GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS");
     }
   if(target.GetType() == cmTarget::MODULE_LIBRARY)
     {
     extraLinkOptions = 
-      m_CurrentMakefile->GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS");
+      this->CurrentMakefile->GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS");
     }
   
   const char* targetLinkFlags = target.GetProperty("LINK_FLAGS");
@@ -1087,7 +1087,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
     {
     buildSettings->AddAttribute("LIBRARY_STYLE", 
                                 this->CreateString("BUNDLE"));
-    if(m_XcodeVersion >= 22)
+    if(this->XcodeVersion >= 22)
       {
       fileType = "compiled.mach-o.executable";
       productType = "com.apple.product-type.tool";
@@ -1173,14 +1173,14 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
       {
       productType = "com.apple.product-type.application";
       std::string f1 =
-        m_CurrentMakefile->GetModulesFile("MacOSXBundleInfo.plist.in");
+        this->CurrentMakefile->GetModulesFile("MacOSXBundleInfo.plist.in");
       if ( f1.size() == 0 )
         {
         cmSystemTools::Error("could not find Mac OSX bundle template file.");
         }
-      std::string f2 = m_CurrentMakefile->GetCurrentOutputDirectory();
+      std::string f2 = this->CurrentMakefile->GetCurrentOutputDirectory();
       f2 += "/Info.plist";
-      m_CurrentMakefile->ConfigureFile(f1.c_str(), f2.c_str(),
+      this->CurrentMakefile->ConfigureFile(f1.c_str(), f2.c_str(),
                                        false, false, false);
       std::string path = 
         this->ConvertToRelativeForXCode(f2.c_str());
@@ -1200,7 +1200,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
   
   std::string dirs;
   std::vector<std::string> includes;
-  m_CurrentLocalGenerator->GetIncludeDirectories(includes);
+  this->CurrentLocalGenerator->GetIncludeDirectories(includes);
   std::vector<std::string>::iterator i = includes.begin();
   std::string fdirs;
   std::set<cmStdString> emitted;
@@ -1385,13 +1385,13 @@ cmGlobalXCodeGenerator::CreateUtilityTarget(cmTarget& cmtarget)
   std::string productTypeString;
   std::string productName;
   const char* globalConfig = 0;
-  if(m_XcodeVersion > 20)
+  if(this->XcodeVersion > 20)
     {
     this->AddConfigurations(target, cmtarget);
     }
   else
     {
-    globalConfig = m_CurrentMakefile->GetDefinition("CMAKE_BUILD_TYPE");  
+    globalConfig = this->CurrentMakefile->GetDefinition("CMAKE_BUILD_TYPE");  
     }
   this->CreateBuildSettings(cmtarget, 
                             buildSettings, fileTypeString, 
@@ -1409,7 +1409,7 @@ cmGlobalXCodeGenerator::CreateUtilityTarget(cmTarget& cmtarget)
 void cmGlobalXCodeGenerator::AddConfigurations(cmXCodeObject* target,
                                                cmTarget& cmtarget)
 {
-  std::string configTypes = m_CurrentMakefile->GetRequiredDefinition("CMAKE_CONFIGURATION_TYPES");
+  std::string configTypes = this->CurrentMakefile->GetRequiredDefinition("CMAKE_CONFIGURATION_TYPES");
   std::vector<std::string> configVectorIn;
   std::vector<std::string> configVector;
   configVectorIn.push_back(configTypes);
@@ -1467,13 +1467,13 @@ cmGlobalXCodeGenerator::CreateXCodeTarget(cmTarget& cmtarget,
   std::string productTypeString;
   std::string productName;
   const char* globalConfig = 0;
-  if(m_XcodeVersion > 20)
+  if(this->XcodeVersion > 20)
     {
     this->AddConfigurations(target, cmtarget);
     }
   else
     {
-    globalConfig = m_CurrentMakefile->GetDefinition("CMAKE_BUILD_TYPE");  
+    globalConfig = this->CurrentMakefile->GetDefinition("CMAKE_BUILD_TYPE");  
     }
   this->CreateBuildSettings(cmtarget, 
                             buildSettings, fileTypeString, 
@@ -1507,8 +1507,8 @@ cmXCodeObject* cmGlobalXCodeGenerator::FindXCodeTarget(cmTarget* t)
     {
     return 0;
     }
-  for(std::vector<cmXCodeObject*>::iterator i = m_XCodeObjects.begin();
-      i != m_XCodeObjects.end(); ++i)
+  for(std::vector<cmXCodeObject*>::iterator i = this->XCodeObjects.begin();
+      i != this->XCodeObjects.end(); ++i)
     {
     cmXCodeObject* o = *i;
     if(o->GetcmTarget() == t)
@@ -1547,7 +1547,7 @@ void cmGlobalXCodeGenerator::AddDependTarget(cmXCodeObject* target,
       this->CreateObject(cmXCodeObject::PBXContainerItemProxy);
     container->SetComment("PBXContainerItemProxy");
     container->AddAttribute("containerPortal",
-                            this->CreateObjectReference(m_RootObject));
+                            this->CreateObjectReference(this->RootObject));
     container->AddAttribute("proxyType", this->CreateString("1"));
     container->AddAttribute("remoteGlobalIDString",
                             this->CreateObjectReference(dependTarget));
@@ -1607,7 +1607,7 @@ void cmGlobalXCodeGenerator::AppendBuildSettingAttribute(cmXCodeObject* target,
                                                          const char* value,
                                                          const char* configName)
 {
-  if(m_XcodeVersion < 21)
+  if(this->XcodeVersion < 21)
     {
     // There is only one configuration.  Add the setting to the buildSettings
     // of the target.
@@ -1670,7 +1670,7 @@ void cmGlobalXCodeGenerator::AddDependAndLinkInformation(cmXCodeObject* target)
       if(emitted.insert(lib->first).second)
         {
         // Add this dependency.
-        cmTarget* t = this->FindTarget(m_CurrentProject.c_str(),
+        cmTarget* t = this->FindTarget(this->CurrentProject.c_str(),
                                        lib->first.c_str());
         cmXCodeObject* dptarget = this->FindXCodeTarget(t);
         if(dptarget)
@@ -1686,7 +1686,7 @@ void cmGlobalXCodeGenerator::AddDependAndLinkInformation(cmXCodeObject* target)
         = cmtarget->GetUtilities().begin();
       i != cmtarget->GetUtilities().end(); ++i)
     {
-    cmTarget* t = this->FindTarget(m_CurrentProject.c_str(),
+    cmTarget* t = this->FindTarget(this->CurrentProject.c_str(),
                                    i->c_str());
     // if the target is in this project then make target depend
     // on it.  It may not be in this project if this is a sub
@@ -1714,7 +1714,7 @@ void cmGlobalXCodeGenerator::AddDependAndLinkInformation(cmXCodeObject* target)
         m += "\n";
         m += "But it has no xcode target created yet??\n";
         m += "Current project is ";
-        m += m_CurrentProject.c_str();
+        m += this->CurrentProject.c_str();
         cmSystemTools::Error(m.c_str());
         }
       } 
@@ -1722,8 +1722,8 @@ void cmGlobalXCodeGenerator::AddDependAndLinkInformation(cmXCodeObject* target)
 
   // Loop over configuration types and set per-configuration info.
   for(std::vector<std::string>::iterator i =
-        m_CurrentConfigurationTypes.begin();
-      i != m_CurrentConfigurationTypes.end(); ++i)
+        this->CurrentConfigurationTypes.begin();
+      i != this->CurrentConfigurationTypes.end(); ++i)
     {
     // Get the current configuration name.
     const char* configName = i->c_str();
@@ -1736,7 +1736,7 @@ void cmGlobalXCodeGenerator::AddDependAndLinkInformation(cmXCodeObject* target)
     std::vector<cmStdString> libNames;
     std::vector<cmStdString> libDirs;
     std::vector<cmStdString> fullPathLibs;
-    m_CurrentLocalGenerator->ComputeLinkInformation(*cmtarget, configName,
+    this->CurrentLocalGenerator->ComputeLinkInformation(*cmtarget, configName,
                                                     libNames, libDirs,
                                                     &fullPathLibs);
 
@@ -1754,7 +1754,7 @@ void cmGlobalXCodeGenerator::AddDependAndLinkInformation(cmXCodeObject* target)
       {
       if(libDir->size() && *libDir != "/usr/lib")
         {
-        if(m_XcodeVersion > 15)
+        if(this->XcodeVersion > 15)
           {
           // now add the same one but append $(CONFIGURATION) to it:
           linkDirs += " ";
@@ -1804,9 +1804,9 @@ void cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root,
         {
         cmSourceFile file;
         file.SetName("Info",
-                     m_CurrentMakefile->GetCurrentOutputDirectory(),
+                     this->CurrentMakefile->GetCurrentOutputDirectory(),
                      "plist", false);
-        cmtarget.GetSourceFiles().push_back(m_CurrentMakefile->AddSource(file));
+        cmtarget.GetSourceFiles().push_back(this->CurrentMakefile->AddSource(file));
         }
 
       std::vector<cmSourceFile*> & classes = cmtarget.GetSourceFiles();
@@ -1819,7 +1819,7 @@ void cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root,
         cmSourceGroup& sourceGroup = 
           mf->FindSourceGroup(source.c_str(), sourceGroups);
         cmXCodeObject* pbxgroup = this->CreateOrGetPBXGroup(cmtarget, &sourceGroup);
-        m_GroupMap[sf] = pbxgroup;
+        this->GroupMap[sf] = pbxgroup;
         }
       }
     } 
@@ -1831,31 +1831,31 @@ cmXCodeObject* cmGlobalXCodeGenerator::CreateOrGetPBXGroup(cmTarget& cmtarget,
   cmStdString s = cmtarget.GetName();
   s += "/";
   s += sg->GetName();
-  std::map<cmStdString, cmXCodeObject* >::iterator i =  m_GroupNameMap.find(s);
-  if(i != m_GroupNameMap.end())
+  std::map<cmStdString, cmXCodeObject* >::iterator i =  this->GroupNameMap.find(s);
+  if(i != this->GroupNameMap.end())
     {
     return i->second;
     }
-  i = m_TargetGroup.find(cmtarget.GetName());
+  i = this->TargetGroup.find(cmtarget.GetName());
   cmXCodeObject* tgroup = 0;
-  if(i != m_TargetGroup.end())
+  if(i != this->TargetGroup.end())
     {
     tgroup = i->second;
     }
   else
     {
     tgroup = this->CreateObject(cmXCodeObject::PBXGroup);
-    m_TargetGroup[cmtarget.GetName()] = tgroup;
+    this->TargetGroup[cmtarget.GetName()] = tgroup;
     cmXCodeObject* tgroupChildren = 
       this->CreateObject(cmXCodeObject::OBJECT_LIST);
     tgroup->AddAttribute("name", this->CreateString(cmtarget.GetName()));
     tgroup->AddAttribute("children", tgroupChildren);
-    if(m_XcodeVersion == 15)
+    if(this->XcodeVersion == 15)
       {
       tgroup->AddAttribute("refType", this->CreateString("4"));
       }
     tgroup->AddAttribute("sourceTree", this->CreateString("<group>"));
-    m_SourcesGroupChildren->AddObject(tgroup);
+    this->SourcesGroupChildren->AddObject(tgroup);
     }
   
   cmXCodeObject* tgroupChildren = tgroup->GetObject("children");
@@ -1864,13 +1864,13 @@ cmXCodeObject* cmGlobalXCodeGenerator::CreateOrGetPBXGroup(cmTarget& cmtarget,
     this->CreateObject(cmXCodeObject::OBJECT_LIST);
   group->AddAttribute("name", this->CreateString(sg->GetName()));
   group->AddAttribute("children", groupChildren);
-  if(m_XcodeVersion == 15)
+  if(this->XcodeVersion == 15)
     {
     group->AddAttribute("refType", this->CreateString("4"));
     }
   group->AddAttribute("sourceTree", this->CreateString("<group>"));
   tgroupChildren->AddObject(group);
-  m_GroupNameMap[s] = group;
+  this->GroupNameMap[s] = group;
   return group;
 }
 
@@ -1881,14 +1881,14 @@ void cmGlobalXCodeGenerator::CreateXCodeObjects(cmLocalGenerator* root,
   )
 {
   this->ClearXCodeObjects(); 
-  m_RootObject = 0;
-  m_SourcesGroupChildren = 0;
-  m_MainGroupChildren = 0;
+  this->RootObject = 0;
+  this->SourcesGroupChildren = 0;
+  this->MainGroupChildren = 0;
   cmXCodeObject* group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
   group->AddAttribute("COPY_PHASE_STRIP", this->CreateString("NO"));
   cmXCodeObject* developBuildStyle = 
     this->CreateObject(cmXCodeObject::PBXBuildStyle);
-  if(m_XcodeVersion == 15)
+  if(this->XcodeVersion == 15)
     {
     developBuildStyle->AddAttribute("name", this->CreateString("Development"));
     }
@@ -1903,7 +1903,7 @@ void cmGlobalXCodeGenerator::CreateXCodeObjects(cmLocalGenerator* root,
   group->AddAttribute("COPY_PHASE_STRIP", this->CreateString("YES"));
   cmXCodeObject* deployBuildStyle =
     this->CreateObject(cmXCodeObject::PBXBuildStyle);
-  if(m_XcodeVersion == 15)
+  if(this->XcodeVersion == 15)
     {
     deployBuildStyle->AddAttribute("name", this->CreateString("Deployment"));
     }
@@ -1919,32 +1919,32 @@ void cmGlobalXCodeGenerator::CreateXCodeObjects(cmLocalGenerator* root,
   listObjs->AddObject(developBuildStyle);
   listObjs->AddObject(deployBuildStyle);
   cmXCodeObject* mainGroup = this->CreateObject(cmXCodeObject::PBXGroup);
-  m_MainGroupChildren = 
+  this->MainGroupChildren = 
     this->CreateObject(cmXCodeObject::OBJECT_LIST);
-  mainGroup->AddAttribute("children", m_MainGroupChildren);
-  if(m_XcodeVersion == 15)
+  mainGroup->AddAttribute("children", this->MainGroupChildren);
+  if(this->XcodeVersion == 15)
     {
     mainGroup->AddAttribute("refType", this->CreateString("4"));
     }
   mainGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
 
   cmXCodeObject* sourcesGroup = this->CreateObject(cmXCodeObject::PBXGroup);
-  m_SourcesGroupChildren = 
+  this->SourcesGroupChildren = 
     this->CreateObject(cmXCodeObject::OBJECT_LIST);
   sourcesGroup->AddAttribute("name", this->CreateString("Sources"));
-  sourcesGroup->AddAttribute("children", m_SourcesGroupChildren);
-  if(m_XcodeVersion == 15)
+  sourcesGroup->AddAttribute("children", this->SourcesGroupChildren);
+  if(this->XcodeVersion == 15)
     {
     sourcesGroup->AddAttribute("refType", this->CreateString("4"));
     }
   sourcesGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
-  m_MainGroupChildren->AddObject(sourcesGroup);
+  this->MainGroupChildren->AddObject(sourcesGroup);
   // now create the cmake groups 
   this->CreateGroups(root, generators);
   
   cmXCodeObject* productGroup = this->CreateObject(cmXCodeObject::PBXGroup);
   productGroup->AddAttribute("name", this->CreateString("Products"));
-  if(m_XcodeVersion == 15)
+  if(this->XcodeVersion == 15)
     {
     productGroup->AddAttribute("refType", this->CreateString("4"));
     }
@@ -1952,17 +1952,17 @@ void cmGlobalXCodeGenerator::CreateXCodeObjects(cmLocalGenerator* root,
   cmXCodeObject* productGroupChildren = 
     this->CreateObject(cmXCodeObject::OBJECT_LIST);
   productGroup->AddAttribute("children", productGroupChildren);
-  m_MainGroupChildren->AddObject(productGroup);
+  this->MainGroupChildren->AddObject(productGroup);
   
   
-  m_RootObject = this->CreateObject(cmXCodeObject::PBXProject);
-  m_RootObject->SetComment("Project object");
+  this->RootObject = this->CreateObject(cmXCodeObject::PBXProject);
+  this->RootObject->SetComment("Project object");
   group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
-  m_RootObject->AddAttribute("mainGroup", 
+  this->RootObject->AddAttribute("mainGroup", 
                              this->CreateObjectReference(mainGroup));
-  m_RootObject->AddAttribute("buildSettings", group);
-  m_RootObject->AddAttribute("buildStyles", listObjs);
-  m_RootObject->AddAttribute("hasScannedForEncodings",
+  this->RootObject->AddAttribute("buildSettings", group);
+  this->RootObject->AddAttribute("buildStyles", listObjs);
+  this->RootObject->AddAttribute("hasScannedForEncodings",
                              this->CreateString("0"));
   cmXCodeObject* configlist = this->CreateObject(cmXCodeObject::XCConfigurationList);
   cmXCodeObject* configDebug = this->CreateObject(cmXCodeObject::XCBuildConfiguration);
@@ -1974,7 +1974,7 @@ void cmGlobalXCodeGenerator::CreateXCodeObjects(cmLocalGenerator* root,
   configlist->AddAttribute("buildConfigurations", buildConfigurations);
   std::string comment = "Build configuration list for PBXProject ";
   comment += " \"";
-  comment += m_CurrentProject;
+  comment += this->CurrentProject;
   comment += "\"";
   configlist->SetComment(comment.c_str());
   configlist->AddAttribute("defaultConfigurationIsVisible", this->CreateString("0"));
@@ -1986,7 +1986,7 @@ void cmGlobalXCodeGenerator::CreateXCodeObjects(cmLocalGenerator* root,
   configRelease->AddAttribute("name", this->CreateString("Release"));
   configRelease->AddAttribute("buildSettings", buildSettings);
 
-  m_RootObject->AddAttribute("buildConfigurationList", 
+  this->RootObject->AddAttribute("buildConfigurationList", 
                              this->CreateObjectReference(configlist));
 
   std::vector<cmXCodeObject*> targets;
@@ -2020,7 +2020,7 @@ void cmGlobalXCodeGenerator::CreateXCodeObjects(cmLocalGenerator* root,
       productGroupChildren->AddObject(productRef->GetObject());
       }
     }
-  m_RootObject->AddAttribute("targets", allTargets);
+  this->RootObject->AddAttribute("targets", allTargets);
 }
 
 
@@ -2029,11 +2029,11 @@ void
 cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
   std::vector<cmXCodeObject*>& targets)
 { 
-  cmGeneratedFileStream makefileStream(m_CurrentXCodeHackMakefile.c_str());
+  cmGeneratedFileStream makefileStream(this->CurrentXCodeHackMakefile.c_str());
   if(!makefileStream)
     {
     cmSystemTools::Error("Could not create",
-                         m_CurrentXCodeHackMakefile.c_str());
+                         this->CurrentXCodeHackMakefile.c_str());
     return;
     }
   makefileStream.SetCopyIfDifferent(true);
@@ -2044,10 +2044,10 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
   makefileStream 
     << "# up-to-date with anything they link to,avoiding a bug in XCode 1.5\n";
   for(std::vector<std::string>::const_iterator
-        ct = m_CurrentConfigurationTypes.begin();
-      ct != m_CurrentConfigurationTypes.end(); ++ct)
+        ct = this->CurrentConfigurationTypes.begin();
+      ct != this->CurrentConfigurationTypes.end(); ++ct)
     {
-    if(m_XcodeVersion < 21 || ct->empty())
+    if(this->XcodeVersion < 21 || ct->empty())
       {
       makefileStream << "all: ";
       }
@@ -2108,8 +2108,8 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
     "# link.  This forces Xcode to relink the targets from scratch.  It\n"
     "# does not seem to check these dependencies itself.\n";  
   for(std::vector<std::string>::const_iterator
-        ct = m_CurrentConfigurationTypes.begin();
-      ct != m_CurrentConfigurationTypes.end(); ++ct)
+        ct = this->CurrentConfigurationTypes.begin();
+      ct != this->CurrentConfigurationTypes.end(); ++ct)
     {
     const char* configName = 0;
     if(!ct->empty())
@@ -2242,7 +2242,7 @@ cmGlobalXCodeGenerator::OutputXCodeProject(cmLocalGenerator* root,
   xcodeDir += "/";
   xcodeDir += root->GetMakefile()->GetProjectName();
   xcodeDir += ".xcode";
-  if(m_XcodeVersion > 20)
+  if(this->XcodeVersion > 20)
     {
     xcodeDir += "proj";
     }  
@@ -2274,9 +2274,9 @@ cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
   fout << "};\n";
   cmXCodeObject::Indent(1, fout);
   fout << "objectVersion = 39;\n";
-  cmXCodeObject::PrintList(m_XCodeObjects, fout);
+  cmXCodeObject::PrintList(this->XCodeObjects, fout);
   cmXCodeObject::Indent(1, fout);
-  fout << "rootObject = " << m_RootObject->GetId() << ";\n";
+  fout << "rootObject = " << this->RootObject->GetId() << ";\n";
   fout << "}\n";
 }
 
@@ -2292,14 +2292,14 @@ void cmGlobalXCodeGenerator::GetDocumentation(cmDocumentationEntry& entry)
 //----------------------------------------------------------------------------
 std::string cmGlobalXCodeGenerator::ConvertToRelativeForMake(const char* p)
 {
-  if ( !m_CurrentMakefile->IsOn("CMAKE_USE_RELATIVE_PATHS") )
+  if ( !this->CurrentMakefile->IsOn("CMAKE_USE_RELATIVE_PATHS") )
     {
     return cmSystemTools::ConvertToOutputPath(p);
     }
   else
     {
     std::string ret = 
-      this->ConvertToRelativePath(m_CurrentOutputDirectoryComponents, p);
+      this->ConvertToRelativePath(this->CurrentOutputDirectoryComponents, p);
     return cmSystemTools::ConvertToOutputPath(ret.c_str());
     }
 }
@@ -2307,14 +2307,14 @@ std::string cmGlobalXCodeGenerator::ConvertToRelativeForMake(const char* p)
 //----------------------------------------------------------------------------
 std::string cmGlobalXCodeGenerator::ConvertToRelativeForXCode(const char* p)
 {
-  if ( !m_CurrentMakefile->IsOn("CMAKE_USE_RELATIVE_PATHS") )
+  if ( !this->CurrentMakefile->IsOn("CMAKE_USE_RELATIVE_PATHS") )
     {
     return cmSystemTools::ConvertToOutputPath(p);
     }
   else
     {
     std::string ret = 
-      this->ConvertToRelativePath(m_ProjectOutputDirectoryComponents, p);
+      this->ConvertToRelativePath(this->ProjectOutputDirectoryComponents, p);
     return cmSystemTools::ConvertToOutputPath(ret.c_str());
     }
 }
@@ -2340,7 +2340,7 @@ cmGlobalXCodeGenerator
                            const char* suffix,
                            std::string& dir)
 {
-  if(m_XcodeVersion > 20)
+  if(this->XcodeVersion > 20)
     {
     if(config)
       {
diff --git a/Source/cmGlobalXCodeGenerator.h b/Source/cmGlobalXCodeGenerator.h
index 3b848ca..020c706 100644
--- a/Source/cmGlobalXCodeGenerator.h
+++ b/Source/cmGlobalXCodeGenerator.h
@@ -36,7 +36,7 @@ public:
   cmGlobalXCodeGenerator();
   static cmGlobalGenerator* New();
 
-  void SetVersion(int v) { m_XcodeVersion = v;}
+  void SetVersion(int v) { this->XcodeVersion = v;}
   ///! Get the name for the generator.
   virtual const char* GetName() const {
     return cmGlobalXCodeGenerator::GetActualName();}
@@ -104,7 +104,7 @@ private:
                                const char* commandFileName);
   cmXCodeObject* FindXCodeTarget(cmTarget*);
   // create cmXCodeObject from these functions so that memory can be managed
-  // correctly.  All objects created are stored in m_XCodeObjects.
+  // correctly.  All objects created are stored in this->XCodeObjects.
   cmXCodeObject* CreateObject(cmXCodeObject::PBXType ptype);
   cmXCodeObject* CreateObject(cmXCodeObject::Type type);
   cmXCodeObject* CreateString(const char* s);
@@ -126,7 +126,7 @@ private:
                            std::string& projectName,
                            const char* buildType);
   std::string ExtractFlag(const char* flag, std::string& flags);
-  // delete all objects in the m_XCodeObjects vector.
+  // delete all objects in the this->XCodeObjects vector.
   void ClearXCodeObjects();
   void CreateXCodeObjects(cmLocalGenerator* root,
                           std::vector<cmLocalGenerator*>& generators);
@@ -160,27 +160,27 @@ protected:
   virtual const char* GetInstallTargetName()      { return "install"; }
   virtual const char* GetPackageTargetName()      { return "package"; }
 
-  int m_XcodeVersion;
-  std::vector<cmXCodeObject*> m_XCodeObjects;
-  cmXCodeObject* m_RootObject;
+  int XcodeVersion;
+  std::vector<cmXCodeObject*> XCodeObjects;
+  cmXCodeObject* RootObject;
 private:
-  cmXCodeObject* m_MainGroupChildren;
-  cmXCodeObject* m_SourcesGroupChildren;
-  cmMakefile* m_CurrentMakefile;
-  cmLocalGenerator* m_CurrentLocalGenerator;
-  std::vector<std::string> m_CurrentConfigurationTypes;
-  std::string m_CurrentReRunCMakeMakefile;
-  std::string m_CurrentXCodeHackMakefile;
-  std::string m_CurrentProject;
-  std::string m_OutputDir; 
-  std::string m_LibraryOutputPath;
-  std::string m_ExecutableOutputPath;
-  std::set<cmStdString> m_TargetDoneSet;
-  std::vector<std::string> m_CurrentOutputDirectoryComponents;
-  std::vector<std::string> m_ProjectOutputDirectoryComponents;
-  std::map<cmSourceFile*, cmXCodeObject* > m_GroupMap;
-  std::map<cmStdString, cmXCodeObject* > m_GroupNameMap;
-  std::map<cmStdString, cmXCodeObject* > m_TargetGroup;
+  cmXCodeObject* MainGroupChildren;
+  cmXCodeObject* SourcesGroupChildren;
+  cmMakefile* CurrentMakefile;
+  cmLocalGenerator* CurrentLocalGenerator;
+  std::vector<std::string> CurrentConfigurationTypes;
+  std::string CurrentReRunCMakeMakefile;
+  std::string CurrentXCodeHackMakefile;
+  std::string CurrentProject;
+  std::string OutputDir; 
+  std::string LibraryOutputPath;
+  std::string ExecutableOutputPath;
+  std::set<cmStdString> TargetDoneSet;
+  std::vector<std::string> CurrentOutputDirectoryComponents;
+  std::vector<std::string> ProjectOutputDirectoryComponents;
+  std::map<cmSourceFile*, cmXCodeObject* > GroupMap;
+  std::map<cmStdString, cmXCodeObject* > GroupNameMap;
+  std::map<cmStdString, cmXCodeObject* > TargetGroup;
 };
 
 #endif
diff --git a/Source/cmIfCommand.cxx b/Source/cmIfCommand.cxx
index f92c647..c7b8d2a 100644
--- a/Source/cmIfCommand.cxx
+++ b/Source/cmIfCommand.cxx
@@ -22,25 +22,25 @@
 bool cmIfFunctionBlocker::
 IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
 {
-  const char* name = lff.m_Name.c_str();
-  const std::vector<cmListFileArgument>& args = lff.m_Arguments;
+  const char* name = lff.Name.c_str();
+  const std::vector<cmListFileArgument>& args = lff.Arguments;
   // always let if statements through
-  if (cmSystemTools::LowerCase(lff.m_Name) == "if")
+  if (cmSystemTools::LowerCase(lff.Name) == "if")
     {
     return false;
     }
   
   // watch for our ELSE or ENDIF
-  if (cmSystemTools::LowerCase(lff.m_Name) == "else" || 
-      cmSystemTools::LowerCase(lff.m_Name) == "endif")
+  if (cmSystemTools::LowerCase(lff.Name) == "else" || 
+      cmSystemTools::LowerCase(lff.Name) == "endif")
     {
-    if (args == m_Args)
+    if (args == this->Args)
       {
       // if it was an else statement then we should change state
       // and block this Else Command
-      if (cmSystemTools::LowerCase(lff.m_Name) == "else")
+      if (cmSystemTools::LowerCase(lff.Name) == "else")
         {
-        m_IsBlocking = !m_IsBlocking;
+        this->IsBlocking = !this->IsBlocking;
         return true;
         }
       // otherwise it must be an ENDIF statement, in that case remove the
@@ -55,8 +55,8 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
       err += ".  Did you mean ";
       err += name;
       err += "( ";
-      for(std::vector<cmListFileArgument>::const_iterator a = m_Args.begin();
-          a != m_Args.end();++a)
+      for(std::vector<cmListFileArgument>::const_iterator a = this->Args.begin();
+          a != this->Args.end();++a)
         {
         err += (a->Quoted?"\"":"");
         err += a->Value;
@@ -67,15 +67,15 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
       cmSystemTools::Error(err.c_str());
       }
     }
-  return m_IsBlocking;
+  return this->IsBlocking;
 }
 
 bool cmIfFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
                                        cmMakefile&)
 {
-  if (cmSystemTools::LowerCase(lff.m_Name) == "endif")
+  if (cmSystemTools::LowerCase(lff.Name) == "endif")
     {
-    if (lff.m_Arguments == m_Args)
+    if (lff.Arguments == this->Args)
       {
       return true;
       }
@@ -89,8 +89,8 @@ ScopeEnded(cmMakefile &mf)
   std::string errmsg = "The end of a CMakeLists file was reached with an IF statement that was not closed properly.\nWithin the directory: ";
   errmsg += mf.GetCurrentDirectory();
   errmsg += "\nThe arguments are: ";
-  for(std::vector<cmListFileArgument>::const_iterator j = m_Args.begin();
-      j != m_Args.end(); ++j)
+  for(std::vector<cmListFileArgument>::const_iterator j = this->Args.begin();
+      j != this->Args.end(); ++j)
     {   
     errmsg += (j->Quoted?"\"":"");
     errmsg += j->Value;
@@ -105,8 +105,8 @@ bool cmIfCommand::InvokeInitialPass(const std::vector<cmListFileArgument>& args)
   char* errorString = 0;
   
   std::vector<std::string> expandedArguments;
-  m_Makefile->ExpandArguments(args, expandedArguments);
-  bool isTrue = cmIfCommand::IsTrue(expandedArguments,&errorString,m_Makefile);
+  this->Makefile->ExpandArguments(args, expandedArguments);
+  bool isTrue = cmIfCommand::IsTrue(expandedArguments,&errorString,this->Makefile);
   
   if (errorString)
     {
@@ -129,9 +129,9 @@ bool cmIfCommand::InvokeInitialPass(const std::vector<cmListFileArgument>& args)
   
   cmIfFunctionBlocker *f = new cmIfFunctionBlocker();
   // if is isn't true block the commands
-  f->m_IsBlocking = !isTrue;
-  f->m_Args = args;
-  m_Makefile->AddFunctionBlocker(f);
+  f->IsBlocking = !isTrue;
+  f->Args = args;
+  this->Makefile->AddFunctionBlocker(f);
   
   return true;
 }
diff --git a/Source/cmIfCommand.h b/Source/cmIfCommand.h
index 914ae56..d9813be 100644
--- a/Source/cmIfCommand.h
+++ b/Source/cmIfCommand.h
@@ -36,8 +36,8 @@ public:
                             cmMakefile &mf);
   virtual void ScopeEnded(cmMakefile &mf);
   
-  std::vector<cmListFileArgument> m_Args;
-  bool m_IsBlocking;
+  std::vector<cmListFileArgument> Args;
+  bool IsBlocking;
 };
 
 /** \class cmIfCommand
diff --git a/Source/cmIncludeCommand.cxx b/Source/cmIncludeCommand.cxx
index 7b7a27e..d418698 100644
--- a/Source/cmIncludeCommand.cxx
+++ b/Source/cmIncludeCommand.cxx
@@ -40,13 +40,13 @@ bool cmIncludeCommand::InitialPass(std::vector<std::string> const& args)
     // Not a path. Maybe module.
     std::string module = fname;
     module += ".cmake";
-    std::string mfile = m_Makefile->GetModulesFile(module.c_str());
+    std::string mfile = this->Makefile->GetModulesFile(module.c_str());
     if ( mfile.size() )
       {
       fname = mfile.c_str();
       }
     }
-  bool readit = m_Makefile->ReadListFile( m_Makefile->GetCurrentListFile(), 
+  bool readit = this->Makefile->ReadListFile( this->Makefile->GetCurrentListFile(), 
                                           fname.c_str() );
   if(!optional && !readit && !cmSystemTools::GetFatalErrorOccured())
     {
diff --git a/Source/cmIncludeDirectoryCommand.cxx b/Source/cmIncludeDirectoryCommand.cxx
index 63fc08c..3bc7787 100644
--- a/Source/cmIncludeDirectoryCommand.cxx
+++ b/Source/cmIncludeDirectoryCommand.cxx
@@ -39,7 +39,7 @@ bool cmIncludeDirectoryCommand::InitialPass(std::vector<std::string> const& args
       {
       cmSystemTools::Error("Empty Include Directory Passed into INCLUDE_DIRECTORIES command.");
       }
-    m_Makefile->AddIncludeDirectory((*i).c_str(), before);
+    this->Makefile->AddIncludeDirectory((*i).c_str(), before);
     }
   return true;
 }
diff --git a/Source/cmIncludeExternalMSProjectCommand.cxx b/Source/cmIncludeExternalMSProjectCommand.cxx
index f3dc6ae..03fe69e 100644
--- a/Source/cmIncludeExternalMSProjectCommand.cxx
+++ b/Source/cmIncludeExternalMSProjectCommand.cxx
@@ -26,7 +26,7 @@ bool cmIncludeExternalMSProjectCommand::InitialPass(std::vector<std::string> con
   }
 // only compile this for win32 to avoid coverage errors
 #ifdef _WIN32
-  if(m_Makefile->GetDefinition("WIN32"))
+  if(this->Makefile->GetDefinition("WIN32"))
     {
     std::string location = args[1];
     
@@ -45,7 +45,7 @@ bool cmIncludeExternalMSProjectCommand::InitialPass(std::vector<std::string> con
 
     const char* no_output = 0;
     const char* no_working_directory = 0;
-    m_Makefile->AddUtilityCommand(utility_name.c_str(), true,
+    this->Makefile->AddUtilityCommand(utility_name.c_str(), true,
                                   no_output, depends,
                                   no_working_directory,
                                   args[0].c_str(), args[1].c_str());
diff --git a/Source/cmIncludeRegularExpressionCommand.cxx b/Source/cmIncludeRegularExpressionCommand.cxx
index 36ee553..56c4e9b 100644
--- a/Source/cmIncludeRegularExpressionCommand.cxx
+++ b/Source/cmIncludeRegularExpressionCommand.cxx
@@ -24,11 +24,11 @@ bool cmIncludeRegularExpressionCommand::InitialPass(std::vector<std::string> con
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  m_Makefile->SetIncludeRegularExpression(args[0].c_str());
+  this->Makefile->SetIncludeRegularExpression(args[0].c_str());
   
   if(args.size() > 1)
     {
-    m_Makefile->SetComplainRegularExpression(args[1].c_str());
+    this->Makefile->SetComplainRegularExpression(args[1].c_str());
     }
   
   return true;
diff --git a/Source/cmInstallCommand.cxx b/Source/cmInstallCommand.cxx
index 449aa44..fcc6941 100644
--- a/Source/cmInstallCommand.cxx
+++ b/Source/cmInstallCommand.cxx
@@ -71,7 +71,7 @@ bool cmInstallCommand::HandleScriptMode(std::vector<std::string> const& args)
       std::string script = args[i];
       if(!cmSystemTools::FileIsFullPath(script.c_str()))
         {
-        script = m_Makefile->GetCurrentDirectory();
+        script = this->Makefile->GetCurrentDirectory();
         script += "/";
         script += args[i];
         }
@@ -80,7 +80,7 @@ bool cmInstallCommand::HandleScriptMode(std::vector<std::string> const& args)
         this->SetError("given a directory as value of SCRIPT argument.");
         return false;
         }
-      m_Makefile->AddInstallGenerator(
+      this->Makefile->AddInstallGenerator(
         new cmInstallScriptGenerator(script.c_str()));
       }
     }
@@ -143,7 +143,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
     else if(doing_targets)
       {
       // Lookup this target in the current directory.
-      if(cmTarget* target = m_Makefile->FindTarget(args[i].c_str()))
+      if(cmTarget* target = this->Makefile->FindTarget(args[i].c_str()))
         {
         // Found the target.  Check its type.
         if(target->GetType() != cmTarget::EXECUTABLE &&
@@ -258,14 +258,14 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
         if(library_destination)
           {
           // The import library uses the LIBRARY properties.
-          m_Makefile->AddInstallGenerator(
+          this->Makefile->AddInstallGenerator(
             new cmInstallTargetGenerator(target, library_dest.c_str(), true,
                                          library_permissions.c_str()));
           }
         if(runtime_destination)
           {
           // The DLL uses the RUNTIME properties.
-          m_Makefile->AddInstallGenerator(
+          this->Makefile->AddInstallGenerator(
             new cmInstallTargetGenerator(target, runtime_dest.c_str(), false,
                                          runtime_permissions.c_str()));
           }
@@ -274,7 +274,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
         if(library_destination)
           {
           // The shared library uses the LIBRARY properties.
-          m_Makefile->AddInstallGenerator(
+          this->Makefile->AddInstallGenerator(
             new cmInstallTargetGenerator(target, library_dest.c_str(), false,
                                          library_permissions.c_str()));
           }
@@ -287,7 +287,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
         // Static libraries and modules use LIBRARY properties.
         if(library_destination)
           {
-          m_Makefile->AddInstallGenerator(
+          this->Makefile->AddInstallGenerator(
             new cmInstallTargetGenerator(target, library_dest.c_str(), false,
                                          library_permissions.c_str()));
           }
@@ -314,7 +314,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
         // Executables use the RUNTIME properties.
         if(runtime_destination)
           {
-          m_Makefile->AddInstallGenerator(
+          this->Makefile->AddInstallGenerator(
             new cmInstallTargetGenerator(target, runtime_dest.c_str(), false,
                                          runtime_permissions.c_str()));
           }
@@ -383,7 +383,7 @@ bool cmInstallCommand::HandleFilesMode(std::vector<std::string> const& args)
       std::string file = args[i];
       if(!cmSystemTools::FileIsFullPath(file.c_str()))
         {
-        file = m_Makefile->GetCurrentDirectory();
+        file = this->Makefile->GetCurrentDirectory();
         file += "/";
         file += args[i];
         }
@@ -459,7 +459,7 @@ bool cmInstallCommand::HandleFilesMode(std::vector<std::string> const& args)
   this->ComputeDestination(destination, dest);
 
   // Create the files install generator.
-  m_Makefile->AddInstallGenerator(
+  this->Makefile->AddInstallGenerator(
     new cmInstallFilesGenerator(files, dest.c_str(), programs,
                                 permissions.c_str(), rename.c_str()));
 
diff --git a/Source/cmInstallFilesCommand.cxx b/Source/cmInstallFilesCommand.cxx
index e559e54..b78a7ce 100644
--- a/Source/cmInstallFilesCommand.cxx
+++ b/Source/cmInstallFilesCommand.cxx
@@ -25,18 +25,18 @@ bool cmInstallFilesCommand::InitialPass(std::vector<std::string> const& argsIn)
     return false;
     }
   std::vector<std::string> args;
-  m_Makefile->ExpandSourceListArguments(argsIn, args, 2);
+  this->Makefile->ExpandSourceListArguments(argsIn, args, 2);
 
   // Create an INSTALL_FILES target specifically for this path.
-  m_TargetName = "INSTALL_FILES_"+args[0];
-  cmTarget& target = m_Makefile->GetTargets()[m_TargetName];
+  this->TargetName = "INSTALL_FILES_"+args[0];
+  cmTarget& target = this->Makefile->GetTargets()[this->TargetName];
   target.SetInAll(false);
-  target.SetType(cmTarget::INSTALL_FILES, m_TargetName.c_str());
+  target.SetType(cmTarget::INSTALL_FILES, this->TargetName.c_str());
   target.SetInstallPath(args[0].c_str());
   
   if((args.size() > 1) && (args[1] == "FILES"))
     {
-    m_IsFilesForm = true;    
+    this->IsFilesForm = true;    
     for(std::vector<std::string>::const_iterator s = args.begin()+2;
         s != args.end(); ++s)
       {
@@ -47,11 +47,11 @@ bool cmInstallFilesCommand::InitialPass(std::vector<std::string> const& argsIn)
     }
   else
     {
-    m_IsFilesForm = false;
+    this->IsFilesForm = false;
     std::vector<std::string>::const_iterator s = args.begin();
     for (++s;s != args.end(); ++s)
       {
-      m_FinalArgs.push_back(*s);
+      this->FinalArgs.push_back(*s);
       }
     }
   
@@ -61,24 +61,24 @@ bool cmInstallFilesCommand::InitialPass(std::vector<std::string> const& argsIn)
 void cmInstallFilesCommand::FinalPass() 
 {
   // No final pass for "FILES" form of arguments.
-  if(m_IsFilesForm)
+  if(this->IsFilesForm)
     {
     return;
     }
   
   std::string testf;
-  std::string ext = m_FinalArgs[0];
+  std::string ext = this->FinalArgs[0];
   std::vector<std::string>& targetSourceLists =
-    m_Makefile->GetTargets()[m_TargetName].GetSourceLists();
+    this->Makefile->GetTargets()[this->TargetName].GetSourceLists();
   
   // two different options
-  if (m_FinalArgs.size() > 1)
+  if (this->FinalArgs.size() > 1)
     {
     // now put the files into the list
-    std::vector<std::string>::iterator s = m_FinalArgs.begin();
+    std::vector<std::string>::iterator s = this->FinalArgs.begin();
     ++s;
     // for each argument, get the files 
-    for (;s != m_FinalArgs.end(); ++s)
+    for (;s != this->FinalArgs.end(); ++s)
       {
       // replace any variables
       std::string temps = *s;
@@ -99,8 +99,8 @@ void cmInstallFilesCommand::FinalPass()
   else     // reg exp list
     {
     std::vector<std::string> files;
-    std::string regex = m_FinalArgs[0].c_str();
-    cmSystemTools::Glob(m_Makefile->GetCurrentDirectory(),
+    std::string regex = this->FinalArgs[0].c_str();
+    cmSystemTools::Glob(this->Makefile->GetCurrentDirectory(),
                         regex.c_str(), files);
     
     std::vector<std::string>::iterator s = files.begin();
@@ -127,10 +127,10 @@ std::string cmInstallFilesCommand::FindInstallSource(const char* name) const
     }
   
   // This is a relative path.
-  std::string tb = m_Makefile->GetCurrentOutputDirectory();
+  std::string tb = this->Makefile->GetCurrentOutputDirectory();
   tb += "/";
   tb += name;
-  std::string ts = m_Makefile->GetCurrentDirectory();
+  std::string ts = this->Makefile->GetCurrentDirectory();
   ts += "/";
   ts += name;
   
diff --git a/Source/cmInstallFilesCommand.h b/Source/cmInstallFilesCommand.h
index ed6fb2e..80b1cda 100644
--- a/Source/cmInstallFilesCommand.h
+++ b/Source/cmInstallFilesCommand.h
@@ -100,9 +100,9 @@ protected:
   std::string FindInstallSource(const char* name) const;
   
  private:
-  std::string m_TargetName;
-  std::vector<std::string> m_FinalArgs;
-  bool m_IsFilesForm;
+  std::string TargetName;
+  std::vector<std::string> FinalArgs;
+  bool IsFilesForm;
 };
 
 
diff --git a/Source/cmInstallProgramsCommand.cxx b/Source/cmInstallProgramsCommand.cxx
index 0489a74..3a72810 100644
--- a/Source/cmInstallProgramsCommand.cxx
+++ b/Source/cmInstallProgramsCommand.cxx
@@ -26,16 +26,16 @@ bool cmInstallProgramsCommand::InitialPass(std::vector<std::string> const& args)
     }
 
   // Create an INSTALL_PROGRAMS target specifically for this path.
-  m_TargetName = "INSTALL_PROGRAMS_"+args[0];
-  cmTarget& target = m_Makefile->GetTargets()[m_TargetName];
+  this->TargetName = "INSTALL_PROGRAMS_"+args[0];
+  cmTarget& target = this->Makefile->GetTargets()[this->TargetName];
   target.SetInAll(false);
-  target.SetType(cmTarget::INSTALL_PROGRAMS, m_TargetName.c_str());
+  target.SetType(cmTarget::INSTALL_PROGRAMS, this->TargetName.c_str());
   target.SetInstallPath(args[0].c_str());
 
   std::vector<std::string>::const_iterator s = args.begin();
   for (++s;s != args.end(); ++s)
     {
-    m_FinalArgs.push_back(*s);
+    this->FinalArgs.push_back(*s);
     }  
   
   return true;
@@ -44,25 +44,25 @@ bool cmInstallProgramsCommand::InitialPass(std::vector<std::string> const& args)
 void cmInstallProgramsCommand::FinalPass() 
 {
   std::vector<std::string>& targetSourceLists =
-    m_Makefile->GetTargets()[m_TargetName].GetSourceLists();
+    this->Makefile->GetTargets()[this->TargetName].GetSourceLists();
 
   bool files_mode = false;
-  if(!m_FinalArgs.empty() && m_FinalArgs[0] == "FILES")
+  if(!this->FinalArgs.empty() && this->FinalArgs[0] == "FILES")
     {
     files_mode = true;
     }
   
   // two different options
-  if (m_FinalArgs.size() > 1 || files_mode)
+  if (this->FinalArgs.size() > 1 || files_mode)
     {
     // for each argument, get the programs 
-    std::vector<std::string>::iterator s = m_FinalArgs.begin();
+    std::vector<std::string>::iterator s = this->FinalArgs.begin();
     if(files_mode)
       {
       // Skip the FILES argument in files mode.
       ++s;
       }
-    for(;s != m_FinalArgs.end(); ++s)
+    for(;s != this->FinalArgs.end(); ++s)
       {
       // add to the result
       targetSourceLists.push_back(this->FindInstallSource(s->c_str()));
@@ -71,8 +71,8 @@ void cmInstallProgramsCommand::FinalPass()
   else     // reg exp list
     {
     std::vector<std::string> programs;
-    cmSystemTools::Glob(m_Makefile->GetCurrentDirectory(),
-                        m_FinalArgs[0].c_str(), programs);
+    cmSystemTools::Glob(this->Makefile->GetCurrentDirectory(),
+                        this->FinalArgs[0].c_str(), programs);
     
     std::vector<std::string>::iterator s = programs.begin();
     // for each argument, get the programs 
@@ -98,10 +98,10 @@ std::string cmInstallProgramsCommand::FindInstallSource(const char* name) const
     }
   
   // This is a relative path.
-  std::string tb = m_Makefile->GetCurrentOutputDirectory();
+  std::string tb = this->Makefile->GetCurrentOutputDirectory();
   tb += "/";
   tb += name;
-  std::string ts = m_Makefile->GetCurrentDirectory();
+  std::string ts = this->Makefile->GetCurrentDirectory();
   ts += "/";
   ts += name;
   
diff --git a/Source/cmInstallProgramsCommand.h b/Source/cmInstallProgramsCommand.h
index f50403b..c960f89 100644
--- a/Source/cmInstallProgramsCommand.h
+++ b/Source/cmInstallProgramsCommand.h
@@ -95,8 +95,8 @@ public:
 protected:
   std::string FindInstallSource(const char* name) const;
 private:
-  std::string m_TargetName;
-  std::vector<std::string> m_FinalArgs;
+  std::string TargetName;
+  std::vector<std::string> FinalArgs;
 };
 
 
diff --git a/Source/cmInstallTargetGenerator.cxx b/Source/cmInstallTargetGenerator.cxx
index c84c4af..538952f 100644
--- a/Source/cmInstallTargetGenerator.cxx
+++ b/Source/cmInstallTargetGenerator.cxx
@@ -292,8 +292,9 @@ void cmInstallTargetGenerator::AddInstallNamePatchRule(std::ostream& os,
     linkType = cmTarget::DEBUG;
     }
   // TODO: Merge with ComputeLinkInformation.
-  const cmTarget::LinkLibraries& inLibs = this->Target->GetLinkLibraries();
-  for(cmTarget::LinkLibraries::const_iterator j = inLibs.begin();
+  const cmTarget::LinkLibraryVectorType& inLibs = 
+    this->Target->GetLinkLibraries();
+  for(cmTarget::LinkLibraryVectorType::const_iterator j = inLibs.begin();
       j != inLibs.end(); ++j)
     {
     std::string lib = j->first;
@@ -309,7 +310,8 @@ void cmInstallTargetGenerator::AddInstallNamePatchRule(std::ostream& os,
           // of the install_name field then we need to create a mapping to be
           // applied after installation.
           std::string for_build = tgt->GetInstallNameDirForBuildTree(config);
-          std::string for_install = tgt->GetInstallNameDirForInstallTree(config);
+          std::string for_install = 
+            tgt->GetInstallNameDirForInstallTree(config);
           if(for_build != for_install)
             {
             // Map from the build-tree install_name.
diff --git a/Source/cmInstallTargetsCommand.cxx b/Source/cmInstallTargetsCommand.cxx
index b86d1f3..5a16d58 100644
--- a/Source/cmInstallTargetsCommand.cxx
+++ b/Source/cmInstallTargetsCommand.cxx
@@ -25,7 +25,7 @@ bool cmInstallTargetsCommand::InitialPass(std::vector<std::string> const& args)
     return false;
     }
 
-  cmTargets &tgts = m_Makefile->GetTargets();
+  cmTargets &tgts = this->Makefile->GetTargets();
   std::vector<std::string>::const_iterator s = args.begin();
   ++s;
   std::string runtime_dir = "/bin";
diff --git a/Source/cmLinkDirectoriesCommand.cxx b/Source/cmLinkDirectoriesCommand.cxx
index 67994f7..30f8e1f 100644
--- a/Source/cmLinkDirectoriesCommand.cxx
+++ b/Source/cmLinkDirectoriesCommand.cxx
@@ -27,7 +27,7 @@ bool cmLinkDirectoriesCommand::InitialPass(std::vector<std::string> const& args)
   for(std::vector<std::string>::const_iterator i = args.begin();
       i != args.end(); ++i)
     {
-    m_Makefile->AddLinkDirectory((*i).c_str());
+    this->Makefile->AddLinkDirectory((*i).c_str());
     }
   return true;
 }
diff --git a/Source/cmLinkLibrariesCommand.cxx b/Source/cmLinkLibrariesCommand.cxx
index ec51212..37d7b08 100644
--- a/Source/cmLinkLibrariesCommand.cxx
+++ b/Source/cmLinkLibrariesCommand.cxx
@@ -36,7 +36,7 @@ bool cmLinkLibrariesCommand::InitialPass(std::vector<std::string> const& args)
         this->SetError("The \"debug\" argument must be followed by a library");
         return false;
         }
-      m_Makefile->AddLinkLibrary(i->c_str(),
+      this->Makefile->AddLinkLibrary(i->c_str(),
                                  cmTarget::DEBUG);
       }
     else if (*i == "optimized")
@@ -47,12 +47,12 @@ bool cmLinkLibrariesCommand::InitialPass(std::vector<std::string> const& args)
         this->SetError("The \"optimized\" argument must be followed by a library");
         return false;
         }
-      m_Makefile->AddLinkLibrary(i->c_str(),
+      this->Makefile->AddLinkLibrary(i->c_str(),
                                  cmTarget::OPTIMIZED);
       }
     else
       {
-      m_Makefile->AddLinkLibrary(i->c_str());  
+      this->Makefile->AddLinkLibrary(i->c_str());  
       }
     }
   
diff --git a/Source/cmListCommand.cxx b/Source/cmListCommand.cxx
index 60cf9e3..6c0b595 100644
--- a/Source/cmListCommand.cxx
+++ b/Source/cmListCommand.cxx
@@ -69,7 +69,7 @@ bool cmListCommand::GetListString(std::string& listString, const char* var)
     }
   // get the old value
   const char* cacheValue
-    = m_Makefile->GetDefinition(var);
+    = this->Makefile->GetDefinition(var);
   if(!cacheValue)
     {
     cmOStringStream str;
@@ -115,7 +115,7 @@ bool cmListCommand::HandleLengthCommand(std::vector<std::string> const& args)
   char buffer[1024];
   sprintf(buffer, "%d", static_cast<int>(length));
 
-  m_Makefile->AddDefinition(variableName.c_str(), buffer);
+  this->Makefile->AddDefinition(variableName.c_str(), buffer);
   return true;
 }
 
@@ -161,7 +161,7 @@ bool cmListCommand::HandleGetCommand(std::vector<std::string> const& args)
     value += varArgsExpanded[item];
     }
 
-  m_Makefile->AddDefinition(variableName.c_str(), value.c_str());
+  this->Makefile->AddDefinition(variableName.c_str(), value.c_str());
   return true;
 }
 
@@ -191,7 +191,7 @@ bool cmListCommand::HandleSetCommand(std::vector<std::string> const& args)
     listString += args[cc];
     }
 
-  m_Makefile->AddDefinition(listName.c_str(), listString.c_str());
+  this->Makefile->AddDefinition(listName.c_str(), listString.c_str());
   return true;
 }
 
@@ -244,7 +244,7 @@ bool cmListCommand::HandleInsertCommand(std::vector<std::string> const& args)
     value += varArgsExpanded[cc];
     }
 
-  m_Makefile->AddDefinition(listName.c_str(), value.c_str());
+  this->Makefile->AddDefinition(listName.c_str(), value.c_str());
   return true;
 }
 
@@ -289,7 +289,7 @@ bool cmListCommand::HandleRemoveCommand(std::vector<std::string> const& args)
     value += varArgsExpanded[cc];
     }
 
-  m_Makefile->AddDefinition(listName.c_str(), value.c_str());
+  this->Makefile->AddDefinition(listName.c_str(), value.c_str());
   return true;
 }
 
@@ -353,7 +353,7 @@ bool cmListCommand::HandleRemoveItemCommand(std::vector<std::string> const& args
       }
     }
 
-  m_Makefile->AddDefinition(listName.c_str(), value.c_str());
+  this->Makefile->AddDefinition(listName.c_str(), value.c_str());
   return true;
 }
 
diff --git a/Source/cmListFileCache.cxx b/Source/cmListFileCache.cxx
index 1692fdc..d520d4a 100644
--- a/Source/cmListFileCache.cxx
+++ b/Source/cmListFileCache.cxx
@@ -50,7 +50,7 @@ bool cmListFile::ParseFile(const char* filename, bool requireProjectCommand)
 
   // Use a simple recursive-descent parser to process the token
   // stream.
-  this->m_ModifiedTime = cmSystemTools::ModifiedTime(filename);
+  this->ModifiedTime = cmSystemTools::ModifiedTime(filename);
   bool parseError = false;
   bool haveNewline = true;
   cmListFileLexer_Token* token;
@@ -66,12 +66,12 @@ bool cmListFile::ParseFile(const char* filename, bool requireProjectCommand)
         {
         haveNewline = false;
         cmListFileFunction inFunction;
-        inFunction.m_Name = token->text;
-        inFunction.m_FilePath = filename;
-        inFunction.m_Line = token->line;
+        inFunction.Name = token->text;
+        inFunction.FilePath = filename;
+        inFunction.Line = token->line;
         if(cmListFileCacheParseFunction(lexer, inFunction, filename))
           {
-          this->m_Functions.push_back(inFunction);
+          this->Functions.push_back(inFunction);
           }
         else
           {
@@ -105,7 +105,7 @@ bool cmListFile::ParseFile(const char* filename, bool requireProjectCommand)
     }
   if (parseError)
     {
-    this->m_ModifiedTime = 0;
+    this->ModifiedTime = 0;
     }
 
   cmListFileLexer_Delete(lexer);
@@ -115,10 +115,10 @@ bool cmListFile::ParseFile(const char* filename, bool requireProjectCommand)
     bool hasProject = false;
     // search for a project command
     for(std::vector<cmListFileFunction>::iterator i 
-          = this->m_Functions.begin();
-        i != this->m_Functions.end(); ++i)
+          = this->Functions.begin();
+        i != this->Functions.end(); ++i)
       {
-      if(cmSystemTools::LowerCase(i->m_Name) == "project")
+      if(cmSystemTools::LowerCase(i->Name) == "project")
         {
         hasProject = true;
         break;
@@ -128,10 +128,10 @@ bool cmListFile::ParseFile(const char* filename, bool requireProjectCommand)
     if(!hasProject)
       {
       cmListFileFunction project;
-      project.m_Name = "PROJECT";
+      project.Name = "PROJECT";
       cmListFileArgument prj("Project", false, filename, 0);
-      project.m_Arguments.push_back(prj);
-      this->m_Functions.insert(this->m_Functions.begin(),project);
+      project.Arguments.push_back(prj);
+      this->Functions.insert(this->Functions.begin(),project);
       }
     }
   return true;
@@ -177,13 +177,13 @@ bool cmListFileCacheParseFunction(cmListFileLexer* lexer,
       {
       cmListFileArgument a(token->text,
                            false, filename, token->line);
-      function.m_Arguments.push_back(a);
+      function.Arguments.push_back(a);
       }
     else if(token->type == cmListFileLexer_Token_ArgumentQuoted)
       {
       cmListFileArgument a(token->text,
                            true, filename, token->line);
-      function.m_Arguments.push_back(a);
+      function.Arguments.push_back(a);
       }
     else if(token->type != cmListFileLexer_Token_Newline)
       {
diff --git a/Source/cmListFileCache.h b/Source/cmListFileCache.h
index c36f562..048e04f 100644
--- a/Source/cmListFileCache.h
+++ b/Source/cmListFileCache.h
@@ -50,21 +50,22 @@ struct cmListFileArgument
 
 struct cmListFileFunction
 {
-  std::string m_Name;
-  std::vector<cmListFileArgument> m_Arguments;
-  const char* m_FilePath;
-  long m_Line;
+  std::string Name;
+  std::vector<cmListFileArgument> Arguments;
+  const char* FilePath;
+  long Line;
 };
 
 struct cmListFile
 {
   cmListFile() 
-    :m_ModifiedTime(0) 
+    :ModifiedTime(0) 
     {
     }
   bool ParseFile(const char* path, bool requireProjectCommand);
-  long int m_ModifiedTime;
-  std::vector<cmListFileFunction> m_Functions;
+
+  long int ModifiedTime;
+  std::vector<cmListFileFunction> Functions;
 };
 
 #endif
diff --git a/Source/cmLoadCacheCommand.cxx b/Source/cmLoadCacheCommand.cxx
index 55c8357..1cd8abc 100644
--- a/Source/cmLoadCacheCommand.cxx
+++ b/Source/cmLoadCacheCommand.cxx
@@ -84,7 +84,7 @@ bool cmLoadCacheCommand::InitialPass(std::vector<std::string> const& args)
       {
       break;
       }
-    m_Makefile->GetCacheManager()->LoadCache(args[i].c_str(), false,
+    this->Makefile->GetCacheManager()->LoadCache(args[i].c_str(), false,
                                              excludes, includes);
     }
 
@@ -188,11 +188,11 @@ void cmLoadCacheCommand::CheckLine(const char* line)
       var = this->Prefix + var;
       if(value.length())
         {
-        m_Makefile->AddDefinition(var.c_str(), value.c_str());
+        this->Makefile->AddDefinition(var.c_str(), value.c_str());
         }
       else
         {
-        m_Makefile->RemoveDefinition(var.c_str());
+        this->Makefile->RemoveDefinition(var.c_str());
         }
       }
     }
diff --git a/Source/cmLoadCommandCommand.cxx b/Source/cmLoadCommandCommand.cxx
index db3b6c5..4fc9b7f 100644
--- a/Source/cmLoadCommandCommand.cxx
+++ b/Source/cmLoadCommandCommand.cxx
@@ -170,7 +170,8 @@ bool cmLoadedCommand::InitialPass(std::vector<std::string> const& args)
     argv[i] = strdup(args[i].c_str());
     }
   cmLoadedCommand::InstallSignalHandlers(info.Name);
-  int result = info.InitialPass((void *)&info,(void *)this->m_Makefile,argc,argv); 
+  int result = info.InitialPass((void *)&info,
+                                (void *)this->Makefile,argc,argv); 
   cmLoadedCommand::InstallSignalHandlers(info.Name, 1);
   cmFreeArguments(argc,argv);
   
@@ -192,7 +193,7 @@ void cmLoadedCommand::FinalPass()
   if (this->info.FinalPass)
     {
     cmLoadedCommand::InstallSignalHandlers(info.Name);
-    this->info.FinalPass((void *)&this->info,(void *)this->m_Makefile);
+    this->info.FinalPass((void *)&this->info,(void *)this->Makefile);
     cmLoadedCommand::InstallSignalHandlers(info.Name, 1);
     }
 }
@@ -223,7 +224,7 @@ bool cmLoadCommandCommand::InitialPass(std::vector<std::string> const& args)
   // Start by removing the definition in case of failure.
   std::string reportVar = "CMAKE_LOADED_COMMAND_";
   reportVar += args[0];
-  m_Makefile->RemoveDefinition(reportVar.c_str());
+  this->Makefile->RemoveDefinition(reportVar.c_str());
 
   // the file must exist
   std::string fullPath = cmDynamicLoader::LibPrefix();
@@ -269,7 +270,7 @@ bool cmLoadCommandCommand::InitialPass(std::vector<std::string> const& args)
     }
 
   // Report what file was loaded for this command.
-  m_Makefile->AddDefinition(reportVar.c_str(), fullPath.c_str());
+  this->Makefile->AddDefinition(reportVar.c_str(), fullPath.c_str());
 
   // find the init function
   std::string initFuncName = args[0] + "Init";
@@ -291,7 +292,7 @@ bool cmLoadCommandCommand::InitialPass(std::vector<std::string> const& args)
     // create a function blocker and set it up
     cmLoadedCommand *f = new cmLoadedCommand();
     (*initFunction)(&f->info);
-    m_Makefile->AddCommand(f);
+    this->Makefile->AddCommand(f);
     return true;
     }
   this->SetError("Attempt to load command failed. "
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 107404c..33b8861 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -32,32 +32,32 @@
 
 cmLocalGenerator::cmLocalGenerator()
 {
-  m_Makefile = new cmMakefile;
-  m_Makefile->SetLocalGenerator(this);
-  m_ExcludeFromAll = false;
-  m_Parent = 0;
-  m_WindowsShell = false;
-  m_IgnoreLibPrefix = false;
-  m_UseRelativePaths = false;
+  this->Makefile = new cmMakefile;
+  this->Makefile->SetLocalGenerator(this);
+  this->ExcludeFromAll = false;
+  this->Parent = 0;
+  this->WindowsShell = false;
+  this->IgnoreLibPrefix = false;
+  this->UseRelativePaths = false;
   this->Configured = false;
 }
 
 cmLocalGenerator::~cmLocalGenerator()
 {
-  delete m_Makefile;
+  delete this->Makefile;
 }
 
 void cmLocalGenerator::Configure()
 {
   // make sure the CMakeFiles dir is there
-  std::string filesDir = m_Makefile->GetStartOutputDirectory();
+  std::string filesDir = this->Makefile->GetStartOutputDirectory();
   filesDir += "/CMakeFiles";
   cmSystemTools::MakeDirectory(filesDir.c_str());
   
   // find & read the list file
-  std::string currentStart = m_Makefile->GetStartDirectory();
+  std::string currentStart = this->Makefile->GetStartDirectory();
   currentStart += "/CMakeLists.txt";
-  m_Makefile->ReadListFile(currentStart.c_str());
+  this->Makefile->ReadListFile(currentStart.c_str());
 
   // at the end of the ReadListFile handle any old style subdirs
   // first get all the subdirectories
@@ -69,7 +69,7 @@ void cmLocalGenerator::Configure()
     {
     if (!(*sdi)->Configured)
       {
-      m_Makefile->ConfigureSubDirectory(*sdi);
+      this->Makefile->ConfigureSubDirectory(*sdi);
       }
     }  
   
@@ -77,7 +77,7 @@ void cmLocalGenerator::Configure()
   
   // Check whether relative paths should be used for optionally
   // relative paths.
-  m_UseRelativePaths = m_Makefile->IsOn("CMAKE_USE_RELATIVE_PATHS");
+  this->UseRelativePaths = this->Makefile->IsOn("CMAKE_USE_RELATIVE_PATHS");
 
   this->Configured = true;
 }
@@ -88,45 +88,45 @@ void cmLocalGenerator::SetupPathConversions()
   // Convert
   std::string outdir; 
   outdir =
-    cmSystemTools::CollapseFullPath(m_Makefile->GetHomeDirectory());
-  cmSystemTools::SplitPath(outdir.c_str(), m_HomeDirectoryComponents);
+    cmSystemTools::CollapseFullPath(this->Makefile->GetHomeDirectory());
+  cmSystemTools::SplitPath(outdir.c_str(), this->HomeDirectoryComponents);
   outdir =
-    cmSystemTools::CollapseFullPath(m_Makefile->GetStartDirectory());
-  cmSystemTools::SplitPath(outdir.c_str(), m_StartDirectoryComponents);
+    cmSystemTools::CollapseFullPath(this->Makefile->GetStartDirectory());
+  cmSystemTools::SplitPath(outdir.c_str(), this->StartDirectoryComponents);
   outdir =
-    cmSystemTools::CollapseFullPath(m_Makefile->GetHomeOutputDirectory());
-  cmSystemTools::SplitPath(outdir.c_str(), m_HomeOutputDirectoryComponents);
+    cmSystemTools::CollapseFullPath(this->Makefile->GetHomeOutputDirectory());
+  cmSystemTools::SplitPath(outdir.c_str(), this->HomeOutputDirectoryComponents);
   outdir =
-    cmSystemTools::CollapseFullPath(m_Makefile->GetStartOutputDirectory());
-cmSystemTools::SplitPath(outdir.c_str(), m_StartOutputDirectoryComponents);
+    cmSystemTools::CollapseFullPath(this->Makefile->GetStartOutputDirectory());
+cmSystemTools::SplitPath(outdir.c_str(), this->StartOutputDirectoryComponents);
 }
 
 
 void cmLocalGenerator::SetGlobalGenerator(cmGlobalGenerator *gg)
 {
-  m_GlobalGenerator = gg;
+  this->GlobalGenerator = gg;
 
   // setup the home directories
-  m_Makefile->SetHomeDirectory(
+  this->Makefile->SetHomeDirectory(
     gg->GetCMakeInstance()->GetHomeDirectory());
-  m_Makefile->SetHomeOutputDirectory(
+  this->Makefile->SetHomeOutputDirectory(
     gg->GetCMakeInstance()->GetHomeOutputDirectory());
 }
 
 void cmLocalGenerator::ConfigureFinalPass()
 {
-  m_Makefile->ConfigureFinalPass();
+  this->Makefile->ConfigureFinalPass();
 }
 
 void cmLocalGenerator::GenerateTestFiles()
 {
-  if ( !m_Makefile->IsOn("CMAKE_TESTING_ENABLED") )
+  if ( !this->Makefile->IsOn("CMAKE_TESTING_ENABLED") )
     {
     return;
     }
-  std::string file = m_Makefile->GetStartOutputDirectory();
+  std::string file = this->Makefile->GetStartOutputDirectory();
   file += "/";
-  if ( m_Makefile->IsSet("CTEST_NEW_FORMAT") )
+  if ( this->Makefile->IsSet("CTEST_NEW_FORMAT") )
     {
     file += "CTestTestfile.cmake";
     }
@@ -138,8 +138,8 @@ void cmLocalGenerator::GenerateTestFiles()
   fout.SetCopyIfDifferent(true);
 
   fout << "# CMake generated Testfile for " << std::endl
-    << "# Source directory: " << m_Makefile->GetStartDirectory() << std::endl
-    << "# Build directory: " << m_Makefile->GetStartOutputDirectory() << std::endl
+    << "# Source directory: " << this->Makefile->GetStartDirectory() << std::endl
+    << "# Build directory: " << this->Makefile->GetStartOutputDirectory() << std::endl
     << "# " << std::endl
     << "# This file replicates the SUBDIRS() and ADD_TEST() commands from the source" << std::endl
     << "# tree CMakeLists.txt file, skipping any SUBDIRS() or ADD_TEST() commands" << std::endl
@@ -148,13 +148,13 @@ void cmLocalGenerator::GenerateTestFiles()
     << "# The next line is critical for Dart to work" << std::endl
     << "# Duh :-)" << std::endl << std::endl;
 
-  const char* testIncludeFile = m_Makefile->GetProperty("TEST_INCLUDE_FILE");
+  const char* testIncludeFile = this->Makefile->GetProperty("TEST_INCLUDE_FILE");
   if ( testIncludeFile )
     {
     fout << "INCLUDE(\"" << testIncludeFile << "\")" << std::endl;
     }
 
-  const std::vector<cmTest*> *tests = m_Makefile->GetTests();
+  const std::vector<cmTest*> *tests = this->Makefile->GetTests();
   std::vector<cmTest*>::const_iterator it;
   for ( it = tests->begin(); it != tests->end(); ++ it )
     {
@@ -228,7 +228,7 @@ void cmLocalGenerator::GenerateTestFiles()
     {
     fout << "SUBDIRS(";
     size_t i;
-    std::string outDir = m_Makefile->GetStartOutputDirectory();
+    std::string outDir = this->Makefile->GetStartOutputDirectory();
     outDir += "/";
     for(i = 0; i < this->Children.size(); ++i)
       {
@@ -248,7 +248,7 @@ void cmLocalGenerator::GenerateTestFiles()
 void cmLocalGenerator::GenerateInstallRules()
 {
   // Compute the install prefix.
-  const char* prefix = m_Makefile->GetDefinition("CMAKE_INSTALL_PREFIX");
+  const char* prefix = this->Makefile->GetDefinition("CMAKE_INSTALL_PREFIX");
 #if defined(_WIN32) && !defined(__CYGWIN__)
   std::string prefix_win32;
   if(!prefix)
@@ -257,7 +257,7 @@ void cmLocalGenerator::GenerateInstallRules()
       {
       prefix_win32 = "C:";
       }
-    const char* project_name = m_Makefile->GetDefinition("PROJECT_NAME");
+    const char* project_name = this->Makefile->GetDefinition("PROJECT_NAME");
     if(project_name && project_name[0])
       {
       prefix_win32 += "/Program Files/";
@@ -278,20 +278,20 @@ void cmLocalGenerator::GenerateInstallRules()
 
   // Compute the set of configurations.
   std::vector<std::string> configurationTypes;
-  if(const char* types = m_Makefile->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
+  if(const char* types = this->Makefile->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
     {
     cmSystemTools::ExpandListArgument(types, configurationTypes);
     }
   const char* config = 0;
   if(configurationTypes.empty())
     {
-    config = m_Makefile->GetDefinition("CMAKE_BUILD_TYPE");
+    config = this->Makefile->GetDefinition("CMAKE_BUILD_TYPE");
     }
 
   // Create the install script file.
-  std::string file = m_Makefile->GetStartOutputDirectory();
-  std::string homedir = m_Makefile->GetHomeOutputDirectory();
-  std::string currdir = m_Makefile->GetCurrentOutputDirectory();
+  std::string file = this->Makefile->GetStartOutputDirectory();
+  std::string homedir = this->Makefile->GetHomeOutputDirectory();
+  std::string currdir = this->Makefile->GetCurrentOutputDirectory();
   cmSystemTools::ConvertToUnixSlashes(file);
   cmSystemTools::ConvertToUnixSlashes(homedir);
   cmSystemTools::ConvertToUnixSlashes(currdir);
@@ -306,9 +306,9 @@ void cmLocalGenerator::GenerateInstallRules()
 
   // Write the header.
   fout << "# Install script for directory: "
-       << m_Makefile->GetCurrentDirectory() << std::endl << std::endl;
-  fout << "# Set the install prefix and remove any trailing slash." << std::endl
-    << "IF(NOT DEFINED CMAKE_INSTALL_PREFIX)" << std::endl
+       << this->Makefile->GetCurrentDirectory() << std::endl << std::endl;
+  fout << "# Set the install prefix" << std::endl
+    << "IF(NOT CMAKE_INSTALL_PREFIX)" << std::endl
     << "  SET(CMAKE_INSTALL_PREFIX \"" << prefix << "\")" << std::endl
     << "ENDIF(NOT DEFINED CMAKE_INSTALL_PREFIX)" << std::endl
     << "STRING(REGEX REPLACE \"/$\" \"\" CMAKE_INSTALL_PREFIX \"${CMAKE_INSTALL_PREFIX}\")" << std::endl
@@ -330,7 +330,7 @@ void cmLocalGenerator::GenerateInstallRules()
 
   // Ask each install generator to write its code.
   std::vector<cmInstallGenerator*> const& installers =
-    m_Makefile->GetInstallGenerators();
+    this->Makefile->GetInstallGenerators();
   for(std::vector<cmInstallGenerator*>::const_iterator gi = installers.begin();
       gi != installers.end(); ++gi)
     {
@@ -378,12 +378,12 @@ void cmLocalGenerator::AddCustomCommandToCreateObject(const char* ofname,
   varString += lang;
   varString += "_COMPILE_OBJECT";
   std::vector<std::string> rules;
-  rules.push_back(m_Makefile->GetRequiredDefinition(varString.c_str()));
+  rules.push_back(this->Makefile->GetRequiredDefinition(varString.c_str()));
   varString = "CMAKE_";
   varString += lang;
   varString += "_FLAGS";
   std::string flags;
-  flags += m_Makefile->GetSafeDefinition(varString.c_str());
+  flags += this->Makefile->GetSafeDefinition(varString.c_str());
   flags += " ";
   flags += this->GetIncludeFlags(lang);
   std::vector<std::string> commands;
@@ -422,7 +422,7 @@ void cmLocalGenerator::AddCustomCommandToCreateObject(const char* ofname,
   cmSystemTools::SplitProgramFromArgs(commands[0].c_str(), command, args);
   std::vector<std::string> argsv;
   argsv.push_back(args);
-  m_Makefile->AddCustomCommandToOutput(ofname, 
+  this->Makefile->AddCustomCommandToOutput(ofname, 
                                        command.c_str(), 
                                        argsv,
                                        source.GetFullPath().c_str(),
@@ -444,11 +444,11 @@ void cmLocalGenerator::AddBuildTargetRule(const char* llang, cmTarget& target)
        !(*i)->GetCustomCommand())
       {
       std::string outExt = 
-        m_GlobalGenerator->GetLanguageOutputExtensionFromExtension(
+        this->GlobalGenerator->GetLanguageOutputExtensionFromExtension(
           (*i)->GetSourceExtension().c_str());
       if(outExt.size() && !(*i)->GetPropertyAsBool("EXTERNAL_OBJECT") )
         {
-        std::string ofname = m_Makefile->GetCurrentOutputDirectory();
+        std::string ofname = this->Makefile->GetCurrentOutputDirectory();
         ofname += "/";
         ofname += (*i)->GetSourceName() + outExt;
         objVector.push_back(ofname);
@@ -470,7 +470,7 @@ void cmLocalGenerator::AddBuildTargetRule(const char* llang, cmTarget& target)
   std::string flags; // should be set
   std::string linkFlags; // should be set 
   this->GetTargetFlags(linkLibs, flags, linkFlags, target);
-  std::string rule = m_Makefile->GetRequiredDefinition(createRule.c_str());
+  std::string rule = this->Makefile->GetRequiredDefinition(createRule.c_str());
   cmLocalGenerator::RuleVariables vars;
   vars.Language = llang;
   vars.Objects = objs.c_str();
@@ -484,7 +484,7 @@ void cmLocalGenerator::AddBuildTargetRule(const char* llang, cmTarget& target)
   
 void cmLocalGenerator::CreateCustomTargetsAndCommands(std::set<cmStdString> const& lang)
 { 
-  cmTargets &tgts = m_Makefile->GetTargets();
+  cmTargets &tgts = this->Makefile->GetTargets();
   for(cmTargets::iterator l = tgts.begin(); 
       l != tgts.end(); l++)
     {
@@ -614,7 +614,7 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable,
       }
     if(variable == "TARGET_IMPLIB")
       {
-      return m_TargetImplib;
+      return this->TargetImplib;
       }
     if(variable == "TARGET_BASE")
       {
@@ -640,7 +640,7 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable,
         std::string name = "CMAKE_SHARED_LIBRARY_SONAME_";
         name += replaceValues.Language;
         name += "_FLAG";
-        if(m_Makefile->GetDefinition(name.c_str()))
+        if(this->Makefile->GetDefinition(name.c_str()))
           {
           return replaceValues.TargetSOName;
           }
@@ -663,7 +663,7 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable,
       }
     }
   std::vector<std::string> enabledLanguages;
-  m_GlobalGenerator->GetEnabledLanguages(enabledLanguages);
+  this->GlobalGenerator->GetEnabledLanguages(enabledLanguages);
   // loop over language specific replace variables
   int pos = 0;
   while(ruleReplaceVars[pos])
@@ -680,7 +680,7 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable,
         {
         std::string arg1 = actualReplace + "_ARG1";
         cmSystemTools::ReplaceString(arg1, "${LANG}", lang);
-        compilerArg1 = m_Makefile->GetDefinition(arg1.c_str());
+        compilerArg1 = this->Makefile->GetDefinition(arg1.c_str());
         }
       if(actualReplace.find("${LANG}") != actualReplace.npos)
         {
@@ -688,7 +688,7 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable,
         }
       if(actualReplace == variable)
         {
-        std::string replace = m_Makefile->GetSafeDefinition(variable.c_str());
+        std::string replace = this->Makefile->GetSafeDefinition(variable.c_str());
         // if the variable is not a FLAG then treat it like a path
         if(variable.find("_FLAG") == variable.npos)
           {
@@ -715,7 +715,7 @@ cmLocalGenerator::ExpandRuleVariables(std::string& s,
                                       const RuleVariables& replaceValues)
 {
   std::vector<std::string> enabledLanguages;
-  m_GlobalGenerator->GetEnabledLanguages(enabledLanguages);
+  this->GlobalGenerator->GetEnabledLanguages(enabledLanguages);
   std::string::size_type start = s.find('<');
   // no variables to expand
   if(start == s.npos)
@@ -783,9 +783,9 @@ const char* cmLocalGenerator::GetIncludeFlags(const char* lang)
     {
     return "";
     }
-  if(m_LanguageToIncludeFlags.count(lang))
+  if(this->LanguageToIncludeFlags.count(lang))
     {
-    return m_LanguageToIncludeFlags[lang].c_str();
+    return this->LanguageToIncludeFlags[lang].c_str();
     }
   cmOStringStream includeFlags;
   std::vector<std::string> includes;
@@ -794,12 +794,12 @@ const char* cmLocalGenerator::GetIncludeFlags(const char* lang)
 
   std::string flagVar = "CMAKE_INCLUDE_FLAG_";
   flagVar += lang;
-  const char* includeFlag = m_Makefile->GetDefinition(flagVar.c_str());
+  const char* includeFlag = this->Makefile->GetDefinition(flagVar.c_str());
   flagVar = "CMAKE_INCLUDE_FLAG_SEP_";
   flagVar += lang;
-  const char* sep = m_Makefile->GetDefinition(flagVar.c_str());
+  const char* sep = this->Makefile->GetDefinition(flagVar.c_str());
   bool quotePaths = false;
-  if(m_Makefile->GetDefinition("CMAKE_QUOTE_INCLUDE_PATHS"))
+  if(this->Makefile->GetDefinition("CMAKE_QUOTE_INCLUDE_PATHS"))
     {
     quotePaths = true;
     }
@@ -855,12 +855,12 @@ const char* cmLocalGenerator::GetIncludeFlags(const char* lang)
     {
     flags[flags.size()-1] = ' ';
     }
-  flags += m_Makefile->GetDefineFlags();
-  m_LanguageToIncludeFlags[lang] = flags;
+  flags += this->Makefile->GetDefineFlags();
+  this->LanguageToIncludeFlags[lang] = flags;
 
   // Use this temorary variable for the return value to work-around a
   // bogus GCC 2.95 warning.
-  const char* ret = m_LanguageToIncludeFlags[lang].c_str();
+  const char* ret = this->LanguageToIncludeFlags[lang].c_str();
   return ret;
 }
 
@@ -880,9 +880,9 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs)
   // current source directory but we cannot fix this because not all
   // native build tools support per-source-file include paths.
   bool inSource =
-    cmSystemTools::ComparePath(m_Makefile->GetStartDirectory(),
-                               m_Makefile->GetStartOutputDirectory());
-  if(!inSource && m_Makefile->IsOn("CMAKE_INCLUDE_CURRENT_DIR"))
+    cmSystemTools::ComparePath(this->Makefile->GetStartDirectory(),
+                               this->Makefile->GetStartOutputDirectory());
+  if(!inSource && this->Makefile->IsOn("CMAKE_INCLUDE_CURRENT_DIR"))
     {
     includeSourceDir = true;
     includeBinaryDir = true;
@@ -891,7 +891,7 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs)
   // CMake versions below 2.0 would add the source tree to the -I path
   // automatically.  Preserve compatibility.
   const char* versionValue =
-    m_Makefile->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY");
+    this->Makefile->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY");
   int major = 0;
   int minor = 0;
   if(versionValue && sscanf(versionValue, "%d.%d", &major, &minor) != 2)
@@ -906,11 +906,11 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs)
   // Hack for VTK 4.0 - 4.4 which depend on the old behavior but do
   // not set the backwards compatibility level automatically.
   const char* vtkSourceDir =
-    m_Makefile->GetDefinition("VTK_SOURCE_DIR");
+    this->Makefile->GetDefinition("VTK_SOURCE_DIR");
   if(vtkSourceDir)
     {
-    const char* vtk_major = m_Makefile->GetDefinition("VTK_MAJOR_VERSION");
-    const char* vtk_minor = m_Makefile->GetDefinition("VTK_MINOR_VERSION");
+    const char* vtk_major = this->Makefile->GetDefinition("VTK_MAJOR_VERSION");
+    const char* vtk_minor = this->Makefile->GetDefinition("VTK_MINOR_VERSION");
     vtk_major = vtk_major? vtk_major : "4";
     vtk_minor = vtk_minor? vtk_minor : "4";
     int vmajor = 0;
@@ -928,15 +928,15 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs)
   // Store the automatic include paths.
   if(includeBinaryDir)
     {
-    dirs.push_back(m_Makefile->GetStartOutputDirectory());
-    emitted.insert(m_Makefile->GetStartOutputDirectory());
+    dirs.push_back(this->Makefile->GetStartOutputDirectory());
+    emitted.insert(this->Makefile->GetStartOutputDirectory());
     }
   if(includeSourceDir)
     {
-    if(emitted.find(m_Makefile->GetStartDirectory()) == emitted.end())
+    if(emitted.find(this->Makefile->GetStartDirectory()) == emitted.end())
       {
-      dirs.push_back(m_Makefile->GetStartDirectory());
-      emitted.insert(m_Makefile->GetStartDirectory());
+      dirs.push_back(this->Makefile->GetStartDirectory());
+      emitted.insert(this->Makefile->GetStartDirectory());
       }
     }
 
@@ -945,7 +945,7 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs)
   // implementations because the wrong headers may be found first.
   emitted.insert("/usr/include");
   if(const char* implicitIncludes =
-     m_Makefile->GetDefinition("CMAKE_PLATFORM_IMPLICIT_INCLUDE_DIRECTORIES"))
+     this->Makefile->GetDefinition("CMAKE_PLATFORM_IMPLICIT_INCLUDE_DIRECTORIES"))
     {
     std::vector<std::string> implicitIncludeVec;
     cmSystemTools::ExpandListArgument(implicitIncludes, implicitIncludeVec);
@@ -956,7 +956,7 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs)
     }
 
   // Construct the ordered list.
-  std::vector<std::string>& includes = m_Makefile->GetIncludeDirectories();
+  std::vector<std::string>& includes = this->Makefile->GetIncludeDirectories();
   for(std::vector<std::string>::iterator i = includes.begin();
       i != includes.end(); ++i)
     {
@@ -973,7 +973,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
                                  std::string& linkFlags,
                                  cmTarget& target)
 {
-  std::string buildType =  m_Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
+  std::string buildType =  this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
   buildType = cmSystemTools::UpperCase(buildType); 
   const char* libraryLinkVariable = "CMAKE_SHARED_LINKER_FLAGS"; // default to shared library
   
@@ -993,17 +993,17 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
       libraryLinkVariable = "CMAKE_MODULE_LINKER_FLAGS";
     case cmTarget::SHARED_LIBRARY:
       { 
-      linkFlags = m_Makefile->GetSafeDefinition(libraryLinkVariable);
+      linkFlags = this->Makefile->GetSafeDefinition(libraryLinkVariable);
       linkFlags += " ";
       if(buildType.size())
         {
         std::string build = libraryLinkVariable;
         build += "_";
         build += buildType;
-        linkFlags += m_Makefile->GetSafeDefinition(build.c_str());
+        linkFlags += this->Makefile->GetSafeDefinition(build.c_str());
         linkFlags += " ";
         }  
-      if(m_Makefile->IsOn("WIN32") && !(m_Makefile->IsOn("CYGWIN") || m_Makefile->IsOn("MINGW")))
+      if(this->Makefile->IsOn("WIN32") && !(this->Makefile->IsOn("CYGWIN") || this->Makefile->IsOn("MINGW")))
         {
         const std::vector<cmSourceFile*>& sources = target.GetSourceFiles();
         for(std::vector<cmSourceFile*>::const_iterator i = sources.begin();
@@ -1011,7 +1011,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
           {
           if((*i)->GetSourceExtension() == "def")
             {
-            linkFlags += m_Makefile->GetSafeDefinition("CMAKE_LINK_DEF_FILE_FLAG");
+            linkFlags += this->Makefile->GetSafeDefinition("CMAKE_LINK_DEF_FILE_FLAG");
             linkFlags += this->Convert((*i)->GetFullPath().c_str(),START_OUTPUT,MAKEFILE);
             linkFlags += " ";
             }
@@ -1030,13 +1030,13 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
       break;
     case cmTarget::EXECUTABLE:
       {
-      linkFlags += m_Makefile->GetSafeDefinition("CMAKE_EXE_LINKER_FLAGS");
+      linkFlags += this->Makefile->GetSafeDefinition("CMAKE_EXE_LINKER_FLAGS");
       linkFlags += " ";
       if(buildType.size())
         {
         std::string build = "CMAKE_EXE_LINKER_FLAGS_";
         build += buildType;
-        linkFlags += m_Makefile->GetSafeDefinition(build.c_str());
+        linkFlags += this->Makefile->GetSafeDefinition(build.c_str());
         linkFlags += " ";
         } 
       const char* linkLanguage = target.GetLinkerLanguage(this->GetGlobalGenerator());
@@ -1052,28 +1052,28 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
       std::string sharedFlagsVar = "CMAKE_SHARED_LIBRARY_";
       sharedFlagsVar += linkLanguage;
       sharedFlagsVar += "_FLAGS";
-      flags += m_Makefile->GetSafeDefinition(flagsVar.c_str());
+      flags += this->Makefile->GetSafeDefinition(flagsVar.c_str());
       flags += " ";
-      flags += m_Makefile->GetSafeDefinition(sharedFlagsVar.c_str());
+      flags += this->Makefile->GetSafeDefinition(sharedFlagsVar.c_str());
       flags += " ";
       cmOStringStream linklibs;
       this->OutputLinkLibraries(linklibs, target, false);
       linkLibs = linklibs.str();
-      if(cmSystemTools::IsOn(m_Makefile->GetDefinition("BUILD_SHARED_LIBS")))
+      if(cmSystemTools::IsOn(this->Makefile->GetDefinition("BUILD_SHARED_LIBS")))
         {
         std::string sFlagVar = std::string("CMAKE_SHARED_BUILD_") + linkLanguage 
           + std::string("_FLAGS");
-        linkFlags += m_Makefile->GetSafeDefinition(sFlagVar.c_str());
+        linkFlags += this->Makefile->GetSafeDefinition(sFlagVar.c_str());
         linkFlags += " ";
         }
       if ( target.GetPropertyAsBool("WIN32_EXECUTABLE") )
         {
-        linkFlags +=  m_Makefile->GetSafeDefinition("CMAKE_CREATE_WIN32_EXE");
+        linkFlags +=  this->Makefile->GetSafeDefinition("CMAKE_CREATE_WIN32_EXE");
         linkFlags += " ";
         }
       else
         {
-        linkFlags +=  m_Makefile->GetSafeDefinition("CMAKE_CREATE_CONSOLE_EXE");
+        linkFlags +=  this->Makefile->GetSafeDefinition("CMAKE_CREATE_CONSOLE_EXE");
         linkFlags += " ";
         }
       const char* targetLinkFlags = target.GetProperty("LINK_FLAGS");
@@ -1108,7 +1108,7 @@ void cmLocalGenerator::OutputLinkLibraries(std::ostream& fout,
   std::string runtimeFlag;
   std::string runtimeSep;
 
-  const char* config = m_Makefile->GetDefinition("CMAKE_BUILD_TYPE");
+  const char* config = this->Makefile->GetDefinition("CMAKE_BUILD_TYPE");
   const char* linkLanguage = tgt.GetLinkerLanguage(this->GetGlobalGenerator());
   if(!linkLanguage)
     {
@@ -1121,12 +1121,12 @@ void cmLocalGenerator::OutputLinkLibraries(std::ostream& fout,
   runTimeFlagVar += linkLanguage;
   runTimeFlagVar += "_FLAG";
   std::string runTimeFlagSepVar = runTimeFlagVar + "_SEP";
-  runtimeFlag = m_Makefile->GetSafeDefinition(runTimeFlagVar.c_str());
-  runtimeSep = m_Makefile->GetSafeDefinition(runTimeFlagSepVar.c_str());
+  runtimeFlag = this->Makefile->GetSafeDefinition(runTimeFlagVar.c_str());
+  runtimeSep = this->Makefile->GetSafeDefinition(runTimeFlagSepVar.c_str());
   
   // concatenate all paths or no?
   bool runtimeConcatenate = ( runtimeSep!="" );
-  if(runtimeFlag == "" || m_Makefile->IsOn("CMAKE_SKIP_RPATH"))
+  if(runtimeFlag == "" || this->Makefile->IsOn("CMAKE_SKIP_RPATH"))
     {
     outputRuntime = false;
     }
@@ -1134,8 +1134,8 @@ void cmLocalGenerator::OutputLinkLibraries(std::ostream& fout,
   // Some search paths should never be emitted
   emitted.insert("");
   emitted.insert("/usr/lib");
-  std::string libPathFlag = m_Makefile->GetRequiredDefinition("CMAKE_LIBRARY_PATH_FLAG");
-  std::string libLinkFlag = m_Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_FLAG");
+  std::string libPathFlag = this->Makefile->GetRequiredDefinition("CMAKE_LIBRARY_PATH_FLAG");
+  std::string libLinkFlag = this->Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_FLAG");
   // collect all the flags needed for linking libraries
   std::string linkLibs;
   
@@ -1145,7 +1145,7 @@ void cmLocalGenerator::OutputLinkLibraries(std::ostream& fout,
   linkFlagsVar += "_FLAGS";
   if( tgt.GetType() == cmTarget::EXECUTABLE )
     {
-    linkLibs = m_Makefile->GetSafeDefinition(linkFlagsVar.c_str());
+    linkLibs = this->Makefile->GetSafeDefinition(linkFlagsVar.c_str());
     linkLibs += " ";
     }
 
@@ -1184,12 +1184,12 @@ void cmLocalGenerator::OutputLinkLibraries(std::ostream& fout,
     if(emitted.insert(libpath).second)
       {
       std::string fullLibPath;
-      if(!m_WindowsShell && m_UseRelativePaths)
+      if(!this->WindowsShell && this->UseRelativePaths)
         {
         fullLibPath = "\"`cd ";
         }
       fullLibPath += libpath;
-      if(!m_WindowsShell && m_UseRelativePaths)
+      if(!this->WindowsShell && this->UseRelativePaths)
         {
         fullLibPath += ";pwd`\"";
         }
@@ -1239,9 +1239,9 @@ void cmLocalGenerator::OutputLinkLibraries(std::ostream& fout,
       }
     fout << " ";
     }
-  if(m_Makefile->GetDefinition("CMAKE_STANDARD_LIBRARIES"))
+  if(this->Makefile->GetDefinition("CMAKE_STANDARD_LIBRARIES"))
     {
-    fout << m_Makefile->GetDefinition("CMAKE_STANDARD_LIBRARIES") << " ";
+    fout << this->Makefile->GetDefinition("CMAKE_STANDARD_LIBRARIES") << " ";
     }
 }
 
@@ -1262,8 +1262,8 @@ cmLocalGenerator::ComputeLinkInformation(cmTarget& target,
 
   // Get the list of libraries against which this target wants to link.
   std::vector<std::string> linkLibraries;
-  const cmTarget::LinkLibraries& inLibs = target.GetLinkLibraries();
-  for(cmTarget::LinkLibraries::const_iterator j = inLibs.begin();
+  const cmTarget::LinkLibraryVectorType& inLibs = target.GetLinkLibraries();
+  for(cmTarget::LinkLibraryVectorType::const_iterator j = inLibs.begin();
       j != inLibs.end(); ++j)
     {
     // For backwards compatibility variables may have been expanded
@@ -1291,7 +1291,7 @@ cmLocalGenerator::ComputeLinkInformation(cmTarget& target,
        (j->second == cmTarget::GENERAL || j->second == linkType))
       {
       // Compute the proper name to use to link this library.
-      cmTarget* tgt = m_GlobalGenerator->FindTarget(0, lib.c_str());
+      cmTarget* tgt = this->GlobalGenerator->FindTarget(0, lib.c_str());
       if(tgt)
         {
         // This is a CMake target.  Ask the target for its real name.
@@ -1316,13 +1316,13 @@ cmLocalGenerator::ComputeLinkInformation(cmTarget& target,
   // Compute the link directory order needed to link the libraries.
   cmOrderLinkDirectories orderLibs;
   orderLibs.SetLinkPrefix(
-    m_Makefile->GetDefinition("CMAKE_STATIC_LIBRARY_PREFIX"));
+    this->Makefile->GetDefinition("CMAKE_STATIC_LIBRARY_PREFIX"));
   orderLibs.AddLinkExtension(
-    m_Makefile->GetDefinition("CMAKE_STATIC_LIBRARY_SUFFIX"));
+    this->Makefile->GetDefinition("CMAKE_STATIC_LIBRARY_SUFFIX"));
   orderLibs.AddLinkExtension(
-    m_Makefile->GetDefinition("CMAKE_SHARED_LIBRARY_SUFFIX"));
+    this->Makefile->GetDefinition("CMAKE_SHARED_LIBRARY_SUFFIX"));
   orderLibs.AddLinkExtension(
-    m_Makefile->GetDefinition("CMAKE_LINK_LIBRARY_SUFFIX"));
+    this->Makefile->GetDefinition("CMAKE_LINK_LIBRARY_SUFFIX"));
   orderLibs.SetLinkInformation(target.GetName(),
                                linkLibraries,
                                linkDirectories);
@@ -1336,9 +1336,9 @@ cmLocalGenerator::ComputeLinkInformation(cmTarget& target,
 
   // Make sure libraries are linked with the proper syntax.
   std::string libLinkFlag =
-    m_Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_FLAG");
+    this->Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_FLAG");
   std::string libLinkSuffix =
-    m_Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_SUFFIX");
+    this->Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_SUFFIX");
   for(std::vector<cmStdString>::iterator l = orderedLibs.begin();
       l != orderedLibs.end(); ++l)
     {
@@ -1387,7 +1387,7 @@ std::string cmLocalGenerator::GetRealDependency(const char* inName,
     }
 
   // Look for a CMake target with the given name.
-  if(cmTarget* target = m_GlobalGenerator->FindTarget(0, name.c_str()))
+  if(cmTarget* target = this->GlobalGenerator->FindTarget(0, name.c_str()))
     {
     switch (target->GetType())
       {
@@ -1422,7 +1422,7 @@ std::string cmLocalGenerator::GetRealDependency(const char* inName,
     }
   // Treat the name as relative to the source directory in which it
   // was given.
-  name = m_Makefile->GetCurrentDirectory();
+  name = this->Makefile->GetCurrentDirectory();
   name += "/";
   name += inName;
   return name;
@@ -1441,16 +1441,16 @@ void cmLocalGenerator::AddSharedFlags(std::string& flags,
     flagsVar = "CMAKE_SHARED_LIBRARY_";
     flagsVar += lang;
     flagsVar += "_FLAGS";
-    this->AppendFlags(flags, m_Makefile->GetDefinition(flagsVar.c_str()));
+    this->AppendFlags(flags, this->Makefile->GetDefinition(flagsVar.c_str()));
     }
 
   // Add flags specific to shared builds.
-  if(cmSystemTools::IsOn(m_Makefile->GetDefinition("BUILD_SHARED_LIBS")))
+  if(cmSystemTools::IsOn(this->Makefile->GetDefinition("BUILD_SHARED_LIBS")))
     {
     flagsVar = "CMAKE_SHARED_BUILD_";
     flagsVar += lang;
     flagsVar += "_FLAGS";
-    this->AppendFlags(flags, m_Makefile->GetDefinition(flagsVar.c_str()));
+    this->AppendFlags(flags, this->Makefile->GetDefinition(flagsVar.c_str()));
     }
 }
 
@@ -1461,14 +1461,14 @@ void cmLocalGenerator::AddConfigVariableFlags(std::string& flags,
 {
   // Add the flags from the variable itself.
   std::string flagsVar = var;
-  this->AppendFlags(flags, m_Makefile->GetDefinition(flagsVar.c_str()));
+  this->AppendFlags(flags, this->Makefile->GetDefinition(flagsVar.c_str()));
 
   // Add the flags from the build-type specific variable.
   if(config && *config)
     {
     flagsVar += "_";
     flagsVar += cmSystemTools::UpperCase(config);
-    this->AppendFlags(flags, m_Makefile->GetDefinition(flagsVar.c_str()));
+    this->AppendFlags(flags, this->Makefile->GetDefinition(flagsVar.c_str()));
     }
 }
 
@@ -1539,29 +1539,29 @@ std::string cmLocalGenerator::Convert(const char* source,
   // Convert the path to a relative path.
   std::string result = source;
 
-  if (!optional || m_UseRelativePaths)
+  if (!optional || this->UseRelativePaths)
     {
     switch (relative)
       {
       case HOME:
         //result = cmSystemTools::CollapseFullPath(result.c_str());
-        result = m_GlobalGenerator->
-          ConvertToRelativePath(m_HomeDirectoryComponents, result.c_str());
+        result = this->GlobalGenerator->
+          ConvertToRelativePath(this->HomeDirectoryComponents, result.c_str());
         break;
       case START:
         //result = cmSystemTools::CollapseFullPath(result.c_str());
-        result = m_GlobalGenerator->
-          ConvertToRelativePath(m_StartDirectoryComponents, result.c_str());
+        result = this->GlobalGenerator->
+          ConvertToRelativePath(this->StartDirectoryComponents, result.c_str());
         break;
       case HOME_OUTPUT:
         //result = cmSystemTools::CollapseFullPath(result.c_str());
-        result = m_GlobalGenerator->
-          ConvertToRelativePath(m_HomeOutputDirectoryComponents, result.c_str());
+        result = this->GlobalGenerator->
+          ConvertToRelativePath(this->HomeOutputDirectoryComponents, result.c_str());
         break;
       case START_OUTPUT:
         //result = cmSystemTools::CollapseFullPath(result.c_str());
-        result = m_GlobalGenerator->
-          ConvertToRelativePath(m_StartOutputDirectoryComponents, result.c_str());
+        result = this->GlobalGenerator->
+          ConvertToRelativePath(this->StartOutputDirectoryComponents, result.c_str());
         break;
       case FULL:
         result = cmSystemTools::CollapseFullPath(result.c_str());
@@ -1578,17 +1578,17 @@ std::string cmLocalGenerator::Convert(const char* source,
     }
   if( output == SHELL)
     {
-    // for shell commands if force unix is on, but m_WindowsShell
+    // for shell commands if force unix is on, but this->WindowsShell
     // is true, then turn off force unix paths for the output path
     // so that the path is windows style and will work with windows
     // cmd.exe.
     bool forceOn =  cmSystemTools::GetForceUnixPaths();
-    if(forceOn && m_WindowsShell)
+    if(forceOn && this->WindowsShell)
       {
       cmSystemTools::SetForceUnixPaths(false);
       }
     result = cmSystemTools::ConvertToOutputPath(result.c_str());
-    if(forceOn && m_WindowsShell)
+    if(forceOn && this->WindowsShell)
       {
       cmSystemTools::SetForceUnixPaths(true);
       }
@@ -1605,7 +1605,7 @@ cmLocalGenerator
 {
   // Convert the old-style install specification from each target to
   // an install generator and run it.
-  cmTargets& tgts = m_Makefile->GetTargets();
+  cmTargets& tgts = this->Makefile->GetTargets();
   for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l)
     {
     // Include the user-specified pre-install script for this target.
diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h
index 6f812ab..1833d2d 100644
--- a/Source/cmLocalGenerator.h
+++ b/Source/cmLocalGenerator.h
@@ -45,7 +45,7 @@ public:
 
   /**
    * Process the CMakeLists files for this directory to fill in the
-   * m_Makefile ivar 
+   * Makefile ivar 
    */
   virtual void Configure();
 
@@ -67,11 +67,11 @@ public:
 
   ///! Get the makefile for this generator
   cmMakefile *GetMakefile() {
-    return this->m_Makefile; };
+    return this->Makefile; };
   
   ///! Get the GlobalGenerator this is associated with
   cmGlobalGenerator *GetGlobalGenerator() {
-    return m_GlobalGenerator; };
+    return this->GlobalGenerator; };
 
   ///! Set the Global Generator, done on creation by the GlobalGenerator
   void SetGlobalGenerator(cmGlobalGenerator *gg);
@@ -111,16 +111,16 @@ public:
   // flag to determine if this project should be included in a parent project
   bool GetExcludeAll()
     {
-      return m_ExcludeFromAll;
+      return this->ExcludeFromAll;
     }
   void SetExcludeAll(bool b)
     {
-      m_ExcludeFromAll = b;
+      this->ExcludeFromAll = b;
     }
   
   ///! set/get the parent generator 
-  cmLocalGenerator* GetParent(){return m_Parent;}
-  void SetParent(cmLocalGenerator* g) { m_Parent = g; g->AddChild(this); }
+  cmLocalGenerator* GetParent(){return this->Parent;}
+  void SetParent(cmLocalGenerator* g) { this->Parent = g; g->AddChild(this); }
 
   ///! set/get the children
   void AddChild(cmLocalGenerator* g) { this->Children.push_back(g); }
@@ -243,28 +243,28 @@ protected:
     std::ostream& os, const char* config,
     std::vector<std::string> const& configurationTypes);
 
-  cmMakefile *m_Makefile;
-  cmGlobalGenerator *m_GlobalGenerator;
+  cmMakefile *Makefile;
+  cmGlobalGenerator *GlobalGenerator;
   // members used for relative path function ConvertToMakefilePath
-  std::string m_RelativePathToSourceDir;
-  std::string m_RelativePathToBinaryDir;
-  std::vector<std::string> m_HomeDirectoryComponents;
-  std::vector<std::string> m_StartDirectoryComponents;
-  std::vector<std::string> m_HomeOutputDirectoryComponents;
-  std::vector<std::string> m_StartOutputDirectoryComponents;
-  bool m_ExcludeFromAll;
-  cmLocalGenerator* m_Parent;
+  std::string RelativePathToSourceDir;
+  std::string RelativePathToBinaryDir;
+  std::vector<std::string> HomeDirectoryComponents;
+  std::vector<std::string> StartDirectoryComponents;
+  std::vector<std::string> HomeOutputDirectoryComponents;
+  std::vector<std::string> StartOutputDirectoryComponents;
+  bool ExcludeFromAll;
+  cmLocalGenerator* Parent;
   std::vector<cmLocalGenerator*> Children;
-  std::map<cmStdString, cmStdString> m_LanguageToIncludeFlags;
-  bool m_WindowsShell;
-  bool m_ForceUnixPath;
-  bool m_UseRelativePaths;
-  bool m_IgnoreLibPrefix;
+  std::map<cmStdString, cmStdString> LanguageToIncludeFlags;
+  bool WindowsShell;
+  bool ForceUnixPath;
+  bool UseRelativePaths;
+  bool IgnoreLibPrefix;
   bool Configured;
 
   // Hack for ExpandRuleVariable until object-oriented version is
   // committed.
-  std::string m_TargetImplib;
+  std::string TargetImplib;
 };
 
 #endif
diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx
index dfe05d1..b436a81 100644
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@@ -38,15 +38,15 @@
 //----------------------------------------------------------------------------
 cmLocalUnixMakefileGenerator3::cmLocalUnixMakefileGenerator3()
 {
-  m_SilentNoColon = false;
-  m_WindowsShell = false;
-  m_IncludeDirective = "include";
-  m_MakefileVariableSize = 0;
-  m_IgnoreLibPrefix = false;
-  m_PassMakeflags = false;
-  m_EchoNeedsQuote = true;
-  m_DefineWindowsNULL = false;
-  m_UnixCD = true;
+  this->SilentNoColon = false;
+  this->WindowsShell = false;
+  this->IncludeDirective = "include";
+  this->MakefileVariableSize = 0;
+  this->IgnoreLibPrefix = false;
+  this->PassMakeflags = false;
+  this->EchoNeedsQuote = true;
+  this->DefineWindowsNULL = false;
+  this->UnixCD = true;
 }
 
 //----------------------------------------------------------------------------
@@ -58,12 +58,12 @@ cmLocalUnixMakefileGenerator3::~cmLocalUnixMakefileGenerator3()
 void cmLocalUnixMakefileGenerator3::Configure()
 {
   // Include the rule file for each object.
-  m_HomeRelativeOutputPath = 
-    cmSystemTools::RelativePath(m_Makefile->GetHomeOutputDirectory(),
-                                m_Makefile->GetStartOutputDirectory());
-  if (m_HomeRelativeOutputPath.size())
+  this->HomeRelativeOutputPath = 
+    cmSystemTools::RelativePath(this->Makefile->GetHomeOutputDirectory(),
+                                this->Makefile->GetStartOutputDirectory());
+  if (this->HomeRelativeOutputPath.size())
     {
-    m_HomeRelativeOutputPath += "/";
+    this->HomeRelativeOutputPath += "/";
     }
   this->cmLocalGenerator::Configure();
 }
@@ -75,7 +75,7 @@ void cmLocalUnixMakefileGenerator3::Generate()
   this->ConfigureOutputPaths();
 
   // Generate the rule files for each target.
-  cmTargets& targets = m_Makefile->GetTargets();
+  cmTargets& targets = this->Makefile->GetTargets();
   std::string empty;
   for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
     {
@@ -84,7 +84,7 @@ void cmLocalUnixMakefileGenerator3::Generate()
     if (tg)
       {
       this->TargetGenerators.push_back(tg);
-      t->second.TraceVSDependencies(empty, m_Makefile);
+      t->second.TraceVSDependencies(empty, this->Makefile);
       tg->WriteRuleFiles();
       }
     }
@@ -110,27 +110,27 @@ void cmLocalUnixMakefileGenerator3::Generate()
 void cmLocalUnixMakefileGenerator3::ConfigureOutputPaths()
 {
   // Format the library and executable output paths.
-  if(const char* libOut = m_Makefile->GetDefinition("LIBRARY_OUTPUT_PATH"))
+  if(const char* libOut = this->Makefile->GetDefinition("LIBRARY_OUTPUT_PATH"))
     {
-    m_LibraryOutputPath = libOut;
-    this->FormatOutputPath(m_LibraryOutputPath, "LIBRARY");
+    this->LibraryOutputPath = libOut;
+    this->FormatOutputPath(this->LibraryOutputPath, "LIBRARY");
     }
-  if(const char* exeOut = m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
+  if(const char* exeOut = this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
     {
-    m_ExecutableOutputPath = exeOut;
-    this->FormatOutputPath(m_ExecutableOutputPath, "EXECUTABLE");
+    this->ExecutableOutputPath = exeOut;
+    this->FormatOutputPath(this->ExecutableOutputPath, "EXECUTABLE");
     }
 
   // Store the configuration name that will be generated.
-  if(const char* config = m_Makefile->GetDefinition("CMAKE_BUILD_TYPE"))
+  if(const char* config = this->Makefile->GetDefinition("CMAKE_BUILD_TYPE"))
     {
     // Use the build type given by the user.
-    m_ConfigurationName = config;
+    this->ConfigurationName = config;
     }
   else
     {
     // No configuration type given.
-    m_ConfigurationName = "";
+    this->ConfigurationName = "";
     }
 }
 
@@ -145,7 +145,7 @@ void cmLocalUnixMakefileGenerator3::FormatOutputPath(std::string& path,
     // relative to the current output directory for this makefile.
     path =
       cmSystemTools::CollapseFullPath(path.c_str(),
-                                      m_Makefile->GetStartOutputDirectory());
+                                      this->Makefile->GetStartOutputDirectory());
 
     // Add a trailing slash for easy appending later.
     if(path.empty() || path[path.size()-1] != '/')
@@ -161,7 +161,7 @@ void cmLocalUnixMakefileGenerator3::FormatOutputPath(std::string& path,
       }
 
     // Add this as a link directory automatically.
-    m_Makefile->AddLinkDirectory(path.c_str());
+    this->Makefile->AddLinkDirectory(path.c_str());
     }
 }
 
@@ -180,7 +180,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
     return;
     }
   // always write the top makefile
-  if (m_Parent)
+  if (this->Parent)
     {
     ruleFileStream.SetCopyIfDifferent(true);
     }
@@ -191,7 +191,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
   // only write local targets unless at the top Keep track of targets already
   // listed.
   std::set<cmStdString> emittedTargets;
-  if (m_Parent)
+  if (this->Parent)
     {
     // write our targets, and while doing it collect up the object
     // file rules
@@ -200,7 +200,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
   else
     {
     cmGlobalUnixMakefileGenerator3 *gg = 
-      static_cast<cmGlobalUnixMakefileGenerator3*>(m_GlobalGenerator);
+      static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
     gg->WriteConvenienceRules(ruleFileStream,emittedTargets);
     }
   
@@ -210,8 +210,8 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
   // now write out the object rules
   // for each object file name
   for (std::map<cmStdString,std::vector<cmTarget *> >::iterator lo = 
-         m_LocalObjectFiles.begin();
-       lo != m_LocalObjectFiles.end(); ++lo)
+         this->LocalObjectFiles.begin();
+       lo != this->LocalObjectFiles.end(); ++lo)
     {
     commands.clear();
     // for each target using the object file
@@ -226,8 +226,8 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
       commands.push_back(this->GetRecursiveMakeCall
                          (tgtMakefileName.c_str(),targetName.c_str()));  
       this->CreateCDCommand(commands,
-                                    m_Makefile->GetHomeOutputDirectory(),
-                                    m_Makefile->GetStartOutputDirectory());
+                                    this->Makefile->GetHomeOutputDirectory(),
+                                    this->Makefile->GetStartOutputDirectory());
       }
     this->WriteMakeRule(ruleFileStream, 
                         "target for object file", 
@@ -238,7 +238,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
   if(emittedTargets.insert("help").second)
     {
     cmGlobalUnixMakefileGenerator3 *gg = 
-      static_cast<cmGlobalUnixMakefileGenerator3*>(m_GlobalGenerator);
+      static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
     gg->WriteHelpRule(ruleFileStream,this);
     }
 
@@ -254,7 +254,7 @@ void cmLocalUnixMakefileGenerator3
 
   // for each target we just provide a rule to cd up to the top and do a make
   // on the target
-  cmTargets& targets = m_Makefile->GetTargets();
+  cmTargets& targets = this->Makefile->GetTargets();
   std::string localName;
   for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
     {
@@ -276,8 +276,8 @@ void cmLocalUnixMakefileGenerator3
       commands.push_back(this->GetRecursiveMakeCall
                          ("CMakeFiles/Makefile2",localName.c_str()));
       this->CreateCDCommand(commands,
-                            m_Makefile->GetHomeOutputDirectory(),
-                            m_Makefile->GetStartOutputDirectory());
+                            this->Makefile->GetHomeOutputDirectory(),
+                            this->Makefile->GetStartOutputDirectory());
       this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
                           localName.c_str(), depends, commands, true);
       
@@ -296,7 +296,7 @@ void cmLocalUnixMakefileGenerator3
 //----------------------------------------------------------------------------
 void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile()
 {
-  std::string infoFileName = m_Makefile->GetStartOutputDirectory();
+  std::string infoFileName = this->Makefile->GetStartOutputDirectory();
   infoFileName += "/CMakeFiles/CMakeDirectoryInformation.cmake";
 
   // Open the output file.
@@ -345,13 +345,13 @@ void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile()
   infoFileStream
     << "SET(CMAKE_C_INCLUDE_REGEX_SCAN ";
   this->WriteCMakeArgument(infoFileStream,
-                           m_Makefile->GetIncludeRegularExpression());
+                           this->Makefile->GetIncludeRegularExpression());
   infoFileStream
     << ")\n";
   infoFileStream
     << "SET(CMAKE_C_INCLUDE_REGEX_COMPLAIN ";
   this->WriteCMakeArgument(infoFileStream,
-                           m_Makefile->GetComplainRegularExpression());
+                           this->Makefile->GetComplainRegularExpression());
   infoFileStream
     << ")\n";
   infoFileStream
@@ -366,8 +366,8 @@ void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile()
   infoFileStream
     << "SET(CMAKE_GENERATED_FILES\n";
   for(std::vector<cmSourceFile*>::const_iterator
-        i = m_Makefile->GetSourceFiles().begin();
-      i != m_Makefile->GetSourceFiles().end(); ++i)
+        i = this->Makefile->GetSourceFiles().begin();
+      i != this->Makefile->GetSourceFiles().end(); ++i)
     {
     cmSourceFile* src = *i;
     if(src->GetPropertyAsBool("GENERATED"))
@@ -389,7 +389,7 @@ std::string
 cmLocalUnixMakefileGenerator3
 ::ConvertToFullPath(const std::string& localPath)
 {
-  std::string dir = m_Makefile->GetStartOutputDirectory();
+  std::string dir = this->Makefile->GetStartOutputDirectory();
   dir += "/";
   dir += localPath;
   return dir;
@@ -398,7 +398,7 @@ cmLocalUnixMakefileGenerator3
 
 const std::string &cmLocalUnixMakefileGenerator3::GetHomeRelativeOutputPath()
 {
-  return m_HomeRelativeOutputPath;
+  return this->HomeRelativeOutputPath;
 }
 
 
@@ -452,7 +452,7 @@ cmLocalUnixMakefileGenerator3
   if(symbolic)
     {
     if(const char* sym =
-       m_Makefile->GetDefinition("CMAKE_MAKE_SYMBOLIC_RULE"))
+       this->Makefile->GetDefinition("CMAKE_MAKE_SYMBOLIC_RULE"))
       {
       os << tgt.c_str() << space << ": " << sym << "\n";
       }
@@ -497,7 +497,7 @@ cmLocalUnixMakefileGenerator3
   makefileStream
     << "# Set environment variables for the build.\n"
     << "\n";
-  if(m_DefineWindowsNULL)
+  if(this->DefineWindowsNULL)
     {
     makefileStream
       << "!IF \"$(OS)\" == \"Windows_NT\"\n"
@@ -506,7 +506,7 @@ cmLocalUnixMakefileGenerator3
       << "NULL=nul\n"
       << "!ENDIF\n";
     }
-  if(m_WindowsShell)
+  if(this->WindowsShell)
     {
      makefileStream
        << "SHELL = C:\\WINDOWS\\system32\\cmd.exe\n";
@@ -520,7 +520,7 @@ cmLocalUnixMakefileGenerator3
     }
 
   std::string cmakecommand =
-      m_Makefile->GetRequiredDefinition("CMAKE_COMMAND");
+      this->Makefile->GetRequiredDefinition("CMAKE_COMMAND");
   makefileStream
     << "# The CMake executable.\n"
     << "CMAKE_COMMAND = "
@@ -534,26 +534,26 @@ cmLocalUnixMakefileGenerator3
     << " -E remove -f\n"
     << "\n";
   
-  if(m_Makefile->GetDefinition("CMAKE_EDIT_COMMAND"))
+  if(this->Makefile->GetDefinition("CMAKE_EDIT_COMMAND"))
     {
     makefileStream
       << "# The program to use to edit the cache.\n"
       << "CMAKE_EDIT_COMMAND = "
       << (this->ConvertToOutputForExisting(
-            m_Makefile->GetDefinition("CMAKE_EDIT_COMMAND"))) << "\n"
+            this->Makefile->GetDefinition("CMAKE_EDIT_COMMAND"))) << "\n"
       << "\n";
     }
 
   makefileStream
     << "# The top-level source directory on which CMake was run.\n"
     << "CMAKE_SOURCE_DIR = "
-    << this->Convert(m_Makefile->GetHomeDirectory(), FULL, SHELL)
+    << this->Convert(this->Makefile->GetHomeDirectory(), FULL, SHELL)
     << "\n"
     << "\n";
   makefileStream
     << "# The top-level build directory on which CMake was run.\n"
     << "CMAKE_BINARY_DIR = "
-    << this->Convert(m_Makefile->GetHomeOutputDirectory(), FULL, SHELL)
+    << this->Convert(this->Makefile->GetHomeOutputDirectory(), FULL, SHELL)
     << "\n"
     << "\n";
 }
@@ -577,14 +577,14 @@ cmLocalUnixMakefileGenerator3
   std::vector<std::string> commands;
   std::vector<std::string> no_depends;
   commands.clear();
-  if(m_Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
+  if(this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
     {
     makefileStream
       << "# Produce verbose output by default.\n"
       << "VERBOSE = 1\n"
       << "\n";
     }
-  if(m_SilentNoColon)
+  if(this->SilentNoColon)
     {
     makefileStream << "$(VERBOSE).SILENT\n";
     }
@@ -635,11 +635,11 @@ cmLocalUnixMakefileGenerator3
   std::vector<std::string> no_depends;
   std::vector<std::string> commands;
   commands.push_back(runRule);
-  if(m_Parent)
+  if(this->Parent)
     {
     this->CreateCDCommand(commands,
-                          m_Makefile->GetHomeOutputDirectory(),
-                          m_Makefile->GetStartOutputDirectory());
+                          this->Makefile->GetHomeOutputDirectory(),
+                          this->Makefile->GetStartOutputDirectory());
     }
   this->WriteMakeRule(makefileStream,
                       "Special rule to run CMake to check the build system "
@@ -686,10 +686,10 @@ cmLocalUnixMakefileGenerator3
 std::string
 cmLocalUnixMakefileGenerator3::GetRelativeTargetDirectory(cmTarget& target)
 {
-  std::string dir = m_Makefile->GetStartOutputDirectory();
+  std::string dir = this->Makefile->GetStartOutputDirectory();
   dir += "/";
   dir += this->GetTargetDirectory(target);
-  dir = cmSystemTools::RelativePath(m_Makefile->GetHomeOutputDirectory(), dir.c_str());
+  dir = cmSystemTools::RelativePath(this->Makefile->GetHomeOutputDirectory(), dir.c_str());
   return this->Convert(dir.c_str(),NONE,MAKEFILE);
 }
 
@@ -703,7 +703,7 @@ cmLocalUnixMakefileGenerator3
 {
   // Add a dependency on the rule file itself unless an option to skip
   // it is specifically enabled by the user or project.
-  const char* nodep = m_Makefile->GetDefinition("CMAKE_SKIP_RULE_DEPENDENCY");
+  const char* nodep = this->Makefile->GetDefinition("CMAKE_SKIP_RULE_DEPENDENCY");
   if(!nodep || cmSystemTools::IsOff(nodep))
     {
     depends.push_back(ruleFileName);
@@ -734,7 +734,7 @@ cmLocalUnixMakefileGenerator3
     {
     // Lookup the real name of the dependency in case it is a CMake target.
     std::string dep = this->GetRealDependency(d->c_str(),
-                                              m_ConfigurationName.c_str());
+                                              this->ConfigurationName.c_str());
     depends.push_back(dep);
     }
 }
@@ -782,12 +782,12 @@ cmLocalUnixMakefileGenerator3
         {
         cmd += " ";
         bool forceOn =  cmSystemTools::GetForceUnixPaths();
-        if(forceOn && m_WindowsShell)
+        if(forceOn && this->WindowsShell)
           {
           cmSystemTools::SetForceUnixPaths(false);
           }
         cmd += cmSystemTools::EscapeSpaces(commandLine[j].c_str());
-        if(forceOn && m_WindowsShell)
+        if(forceOn && this->WindowsShell)
           {
           cmSystemTools::SetForceUnixPaths(true);
           }
@@ -797,14 +797,14 @@ cmLocalUnixMakefileGenerator3
     }
 
   // push back the custom commands
-  const char* dir  = m_Makefile->GetStartOutputDirectory();
+  const char* dir  = this->Makefile->GetStartOutputDirectory();
   // if the command specified a working directory use it.
   if(cc.GetWorkingDirectory())
     {
     dir = cc.GetWorkingDirectory();
     }
   this->CreateCDCommand(commands1, dir,
-                        m_Makefile->GetHomeOutputDirectory());
+                        this->Makefile->GetHomeOutputDirectory());
 
   commands.insert(commands.end(), commands1.begin(), commands1.end());
 }
@@ -818,7 +818,7 @@ cmLocalUnixMakefileGenerator3
 {
   if(!files.empty())
     {
-    std::string cleanfile = m_Makefile->GetCurrentOutputDirectory();
+    std::string cleanfile = this->Makefile->GetCurrentOutputDirectory();
     cleanfile += "/";
     cleanfile += this->GetTargetDirectory(target);
     cleanfile += "/cmake_clean";
@@ -864,12 +864,12 @@ cmLocalUnixMakefileGenerator3::AppendEcho(std::vector<std::string>& commands,
         {
         // Add a command to echo this line.
         std::string cmd = "@echo ";
-        if(m_EchoNeedsQuote)
+        if(this->EchoNeedsQuote)
           {
           cmd += "\"";
           }
         cmd += line;
-        if(m_EchoNeedsQuote)
+        if(this->EchoNeedsQuote)
           {
           cmd += "\"";
           }
@@ -921,10 +921,10 @@ cmLocalUnixMakefileGenerator3::CreateSafeUniqueObjectFileName(const char* sin)
 {
   // Look for an existing mapped name for this object file.
   std::map<cmStdString,cmStdString>::iterator it =
-    m_UniqueObjectNamesMap.find(sin);
+    this->UniqueObjectNamesMap.find(sin);
 
   // If no entry exists create one.
-  if(it == m_UniqueObjectNamesMap.end())
+  if(it == this->UniqueObjectNamesMap.end())
     {
     // Start with the original name.
     std::string ssin = sin;
@@ -944,7 +944,7 @@ cmLocalUnixMakefileGenerator3::CreateSafeUniqueObjectFileName(const char* sin)
     cmSystemTools::ReplaceString(ssin, " ", "_");
 
     // Mangle the name if necessary.
-    if(m_Makefile->IsOn("CMAKE_MANGLE_OBJECT_FILE_NAMES"))
+    if(this->Makefile->IsOn("CMAKE_MANGLE_OBJECT_FILE_NAMES"))
       {
       bool done;
       int cc = 0;
@@ -955,8 +955,8 @@ cmLocalUnixMakefileGenerator3::CreateSafeUniqueObjectFileName(const char* sin)
       do
         {
         done = true;
-        for ( it = m_UniqueObjectNamesMap.begin();
-              it != m_UniqueObjectNamesMap.end();
+        for ( it = this->UniqueObjectNamesMap.begin();
+              it != this->UniqueObjectNamesMap.end();
               ++ it )
           {
           if ( it->second == ssin )
@@ -977,7 +977,7 @@ cmLocalUnixMakefileGenerator3::CreateSafeUniqueObjectFileName(const char* sin)
 
     // Insert the newly mapped object file name.
     std::map<cmStdString, cmStdString>::value_type e(sin, ssin);
-    it = m_UniqueObjectNamesMap.insert(e).first;
+    it = this->UniqueObjectNamesMap.insert(e).first;
     }
 
   // Return the map entry.
@@ -996,24 +996,24 @@ cmLocalUnixMakefileGenerator3
   // if there is no restriction on the length of make variables
   // and there are no "." charactors in the string, then return the
   // unmodified combination.
-  if((!m_MakefileVariableSize && unmodified.find('.') == s.npos)
-     && (!m_MakefileVariableSize && unmodified.find('-') == s.npos))
+  if((!this->MakefileVariableSize && unmodified.find('.') == s.npos)
+     && (!this->MakefileVariableSize && unmodified.find('-') == s.npos))
     {
     return unmodified;
     }
 
   // see if the variable has been defined before and return
   // the modified version of the variable
-  std::map<cmStdString, cmStdString>::iterator i = m_MakeVariableMap.find(unmodified);
-  if(i != m_MakeVariableMap.end())
+  std::map<cmStdString, cmStdString>::iterator i = this->MakeVariableMap.find(unmodified);
+  if(i != this->MakeVariableMap.end())
     {
     return i->second;
     }
   // start with the unmodified variable
   std::string ret = unmodified;
-  // if this there is no value for m_MakefileVariableSize then
+  // if this there is no value for this->MakefileVariableSize then
   // the string must have bad characters in it
-  if(!m_MakefileVariableSize)
+  if(!this->MakefileVariableSize)
     {
     cmSystemTools::ReplaceString(ret, ".", "_");
     cmSystemTools::ReplaceString(ret, "-", "__");
@@ -1021,22 +1021,22 @@ cmLocalUnixMakefileGenerator3
     char buffer[5];
     // make sure the _ version is not already used, if
     // it is used then add number to the end of the variable
-    while(m_ShortMakeVariableMap.count(ret) && ni < 1000)
+    while(this->ShortMakeVariableMap.count(ret) && ni < 1000)
       {
       ++ni;
       sprintf(buffer, "%04d", ni);
       ret = unmodified + buffer;
       }
-    m_ShortMakeVariableMap[ret] = "1";
-    m_MakeVariableMap[unmodified] = ret;
+    this->ShortMakeVariableMap[ret] = "1";
+    this->MakeVariableMap[unmodified] = ret;
     return ret;
     }
 
   // if the string is greater the 32 chars it is an invalid vairable name
   // for borland make
-  if(static_cast<int>(ret.size()) > m_MakefileVariableSize)
+  if(static_cast<int>(ret.size()) > this->MakefileVariableSize)
     {
-    int keep = m_MakefileVariableSize - 8;
+    int keep = this->MakefileVariableSize - 8;
     int size = keep + 3;
     std::string str1 = s;
     std::string str2 = s2;
@@ -1054,7 +1054,7 @@ cmLocalUnixMakefileGenerator3
     int ni = 0;
     sprintf(buffer, "%04d", ni);
     ret = str1 + str2 + buffer;
-    while(m_ShortMakeVariableMap.count(ret) && ni < 1000)
+    while(this->ShortMakeVariableMap.count(ret) && ni < 1000)
       {
       ++ni;
       sprintf(buffer, "%04d", ni);
@@ -1066,10 +1066,10 @@ cmLocalUnixMakefileGenerator3
       return unmodified;
       }
     // once an unused variable is found
-    m_ShortMakeVariableMap[ret] = "1";
+    this->ShortMakeVariableMap[ret] = "1";
     }
   // always make an entry into the unmodified to variable map
-  m_MakeVariableMap[unmodified] = ret;
+  this->MakeVariableMap[unmodified] = ret;
   return ret;
 }
 
@@ -1242,7 +1242,7 @@ cmLocalUnixMakefileGenerator3
     
     if (scanner)
       {
-      scanner->SetFileComparison(m_GlobalGenerator->GetCMakeInstance()->GetFileComparison());
+      scanner->SetFileComparison(this->GlobalGenerator->GetCMakeInstance()->GetFileComparison());
       // for each file we need to scan
       std::string srcLang = "CMAKE_DEPENDS_CHECK_";
       srcLang += lang;
@@ -1298,7 +1298,7 @@ void cmLocalUnixMakefileGenerator3
   }
 
   // Write all global targets
-  cmTargets* targets = &(m_Makefile->GetTargets());
+  cmTargets* targets = &(this->Makefile->GetTargets());
   cmTargets::iterator glIt;
   for ( glIt = targets->begin(); glIt != targets->end(); ++ glIt )
     {
@@ -1323,11 +1323,16 @@ void cmLocalUnixMakefileGenerator3
       this->AppendEcho(commands, text);
 
       // Utility targets store their rules in pre- and post-build commands.
-      this->AppendCustomDepends(depends,   glIt->second.GetPreBuildCommands());
-      this->AppendCustomDepends(depends,   glIt->second.GetPostBuildCommands());
-      this->AppendCustomCommands(commands, glIt->second.GetPreBuildCommands());
-      this->AppendCustomCommands(commands, glIt->second.GetPostBuildCommands());
-      this->WriteMakeRule(ruleFileStream, targetString.c_str(), glIt->first.c_str(), depends, commands, true);
+      this->AppendCustomDepends(depends,   
+                                glIt->second.GetPreBuildCommands());
+      this->AppendCustomDepends(depends,   
+                                glIt->second.GetPostBuildCommands());
+      this->AppendCustomCommands(commands, 
+                                 glIt->second.GetPreBuildCommands());
+      this->AppendCustomCommands(commands, 
+                                 glIt->second.GetPostBuildCommands());
+      this->WriteMakeRule(ruleFileStream, targetString.c_str(), 
+                          glIt->first.c_str(), depends, commands, true);
       }
     }
 
@@ -1337,20 +1342,23 @@ void cmLocalUnixMakefileGenerator3
   std::vector<std::string> commands;
 
   // Write the all rule.
-  std::string dir = m_Makefile->GetStartOutputDirectory();
+  std::string dir = this->Makefile->GetStartOutputDirectory();
   dir += "/all";
+
   dir = this->Convert(dir.c_str(),HOME_OUTPUT,MAKEFILE);
+
   depends.push_back("cmake_check_build_system");
+
   commands.push_back
     (this->GetRecursiveMakeCall("CMakeFiles/Makefile2",dir.c_str()));  
   this->CreateCDCommand(commands,
-                                m_Makefile->GetHomeOutputDirectory(),
-                                m_Makefile->GetStartOutputDirectory());
+                                this->Makefile->GetHomeOutputDirectory(),
+                                this->Makefile->GetStartOutputDirectory());
   this->WriteMakeRule(ruleFileStream, "The main all target", "all",
                       depends, commands, true);
 
   // Write the clean rule.
-  dir = m_Makefile->GetStartOutputDirectory();
+  dir = this->Makefile->GetStartOutputDirectory();
   dir += "/clean";
   dir = this->Convert(dir.c_str(),HOME_OUTPUT,MAKEFILE);
   commands.clear();
@@ -1358,19 +1366,19 @@ void cmLocalUnixMakefileGenerator3
   commands.push_back
     (this->GetRecursiveMakeCall("CMakeFiles/Makefile2",dir.c_str()));  
   this->CreateCDCommand(commands,
-                                m_Makefile->GetHomeOutputDirectory(),
-                                m_Makefile->GetStartOutputDirectory());
+                                this->Makefile->GetHomeOutputDirectory(),
+                                this->Makefile->GetStartOutputDirectory());
   this->WriteMakeRule(ruleFileStream, "The main clean target", "clean",
                       depends, commands, true);
 
   // Write the preinstall rule.
-  dir = m_Makefile->GetStartOutputDirectory();
+  dir = this->Makefile->GetStartOutputDirectory();
   dir += "/preinstall";
   dir = this->Convert(dir.c_str(), HOME_OUTPUT,MAKEFILE);
   commands.clear();
   depends.clear();
   const char* noall =
-    m_Makefile->GetDefinition("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY");
+    this->Makefile->GetDefinition("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY");
   if(!noall || cmSystemTools::IsOff(noall))
     {
     // Drive the build before installing.
@@ -1384,8 +1392,8 @@ void cmLocalUnixMakefileGenerator3
   commands.push_back
     (this->GetRecursiveMakeCall("CMakeFiles/Makefile2", dir.c_str()));
   this->CreateCDCommand(commands,
-                        m_Makefile->GetHomeOutputDirectory(),
-                        m_Makefile->GetStartOutputDirectory());
+                        this->Makefile->GetHomeOutputDirectory(),
+                        this->Makefile->GetStartOutputDirectory());
   this->WriteMakeRule(ruleFileStream, "Prepare targets for installation.",
                       "preinstall", depends, commands, true);
 
@@ -1425,7 +1433,7 @@ void cmLocalUnixMakefileGenerator3::CheckDependencies(cmMakefile* mf,
   // For each info file run the check
   cmDependsC checker;
   checker.SetVerbose(verbose);
-  checker.SetFileComparison(m_GlobalGenerator->GetCMakeInstance()->GetFileComparison());
+  checker.SetFileComparison(this->GlobalGenerator->GetCMakeInstance()->GetFileComparison());
   for(std::vector<std::string>::iterator l = files.begin();
       l != files.end(); ++l)
     {
@@ -1489,7 +1497,7 @@ void cmLocalUnixMakefileGenerator3
       {
       cmakefileStream << "  \"" << (*csIter)->GetFullPath() << "\"\n";
       // Get the full path name of the object file.
-      std::string obj = m_Makefile->GetStartOutputDirectory();
+      std::string obj = this->Makefile->GetStartOutputDirectory();
       obj += "/";
       obj += this->GetObjectFileName(target, **csIter);
       cmakefileStream << "  \"" << 
@@ -1535,7 +1543,7 @@ cmLocalUnixMakefileGenerator3
     objectName = objectName.substr(0, dot_pos);
     }
   objectName +=
-    m_GlobalGenerator->GetLanguageOutputExtensionFromExtension(
+    this->GlobalGenerator->GetLanguageOutputExtensionFromExtension(
       source.GetSourceExtension().c_str());
 
   // Convert to a safe name.
@@ -1557,7 +1565,7 @@ void cmLocalUnixMakefileGenerator3::WriteDisclaimer(std::ostream& os)
 {
   os
     << "# CMAKE generated file: DO NOT EDIT!\n"
-    << "# Generated by \"" << m_GlobalGenerator->GetName() << "\""
+    << "# Generated by \"" << this->GlobalGenerator->GetName() << "\""
     << " Generator, CMake Version "
     << cmMakefile::GetMajorVersion() << "."
     << cmMakefile::GetMinorVersion() << "\n\n";
@@ -1713,7 +1721,7 @@ void cmLocalUnixMakefileGenerator3
     return;
     }
   
-  if(!m_UnixCD)
+  if(!this->UnixCD)
     {
     // On Windows we must perform each step separately and then change
     // back because the shell keeps the working directory between
@@ -1756,7 +1764,7 @@ cmLocalUnixMakefileGenerator3
 ::GetSourceFileLanguage(const cmSourceFile& source)
 {
   // Identify the language of the source file.
-  return (m_GlobalGenerator
+  return (this->GlobalGenerator
           ->GetLanguageFromExtension(source.GetSourceExtension().c_str()));
 }
 
diff --git a/Source/cmLocalUnixMakefileGenerator3.h b/Source/cmLocalUnixMakefileGenerator3.h
index 869ad9f..47f31db 100644
--- a/Source/cmLocalUnixMakefileGenerator3.h
+++ b/Source/cmLocalUnixMakefileGenerator3.h
@@ -31,7 +31,7 @@ class cmSourceFile;
  * \brief Write a LocalUnix makefiles.
  *
  * cmLocalUnixMakefileGenerator3 produces a LocalUnix makefile from its
- * member m_Makefile.
+ * member Makefile.
  */
 class cmLocalUnixMakefileGenerator3 : public cmLocalGenerator
 {
@@ -41,7 +41,7 @@ public:
 
   /**
    * Process the CMakeLists files for this directory to fill in the
-   * m_Makefile ivar 
+   * Makefile ivar 
    */
   virtual void Configure();
 
@@ -83,61 +83,61 @@ public:
    * that do not use environment variables.
    *
    */
-  void SetPassMakeflags(bool s){m_PassMakeflags = s;}
-  bool GetPassMakeflags() { return m_PassMakeflags; }
+  void SetPassMakeflags(bool s){this->PassMakeflags = s;}
+  bool GetPassMakeflags() { return this->PassMakeflags; }
   
   /**
    * Set the flag used to keep the make program silent.
    */
-  void SetMakeSilentFlag(const char* s) { m_MakeSilentFlag = s; }
-  std::string &GetMakeSilentFlag() { return m_MakeSilentFlag; }
+  void SetMakeSilentFlag(const char* s) { this->MakeSilentFlag = s; }
+  std::string &GetMakeSilentFlag() { return this->MakeSilentFlag; }
 
   /** Set whether the echo command needs its argument quoted.  */
-  void SetEchoNeedsQuote(bool b) { m_EchoNeedsQuote = b; }
+  void SetEchoNeedsQuote(bool b) { this->EchoNeedsQuote = b; }
 
   /**
    * Set to true if the shell being used is the windows shell.
    * This controls if statements in the makefile and the SHELL variable.
    * The default is false.
    */
-  void SetWindowsShell(bool v)  {m_WindowsShell = v;}
+  void SetWindowsShell(bool v)  {this->WindowsShell = v;}
 
   /**
    * If set to true, then NULL is set to nil for non Windows_NT.
    * This uses make syntax used by nmake and borland.
    * The default is false.
    */
-  void SetDefineWindowsNULL(bool v)  {m_DefineWindowsNULL = v;}
+  void SetDefineWindowsNULL(bool v)  {this->DefineWindowsNULL = v;}
 
   /**
    * If set to true, cd dir && command is used to 
    * run commands in a different directory.
    */
-  void SetUnixCD(bool v)  {m_UnixCD = v;}
+  void SetUnixCD(bool v)  {this->UnixCD = v;}
 
   /**
    * Set Support Verbose Variable.  If true, then .SILENT will
    * be not end with :  i.e. .SILENT: or .SILENT
    */
-  void SetSilentNoColon(bool v)  {m_SilentNoColon = v;}
+  void SetSilentNoColon(bool v)  {this->SilentNoColon = v;}
 
   /**
    * Set the string used to include one makefile into another default
    * is include.
    */
-  void SetIncludeDirective(const char* s) { m_IncludeDirective = s; }
-  const char *GetIncludeDirective() { return m_IncludeDirective.c_str(); }
+  void SetIncludeDirective(const char* s) { this->IncludeDirective = s; }
+  const char *GetIncludeDirective() { return this->IncludeDirective.c_str(); }
 
   /**
    * Set max makefile variable size, default is 0 which means unlimited.
    */
-  void SetMakefileVariableSize(int s) { m_MakefileVariableSize = s; }
+  void SetMakefileVariableSize(int s) { this->MakefileVariableSize = s; }
 
   /**
    * If ignore lib prefix is true, then do not strip lib from the name
    * of a library.
    */
-  void SetIgnoreLibPrefix(bool s) { m_IgnoreLibPrefix = s; }
+  void SetIgnoreLibPrefix(bool s) { this->IgnoreLibPrefix = s; }
 
   // used in writing out Cmake files such as WriteDirectoryInformation
   static void WriteCMakeArgument(std::ostream& os, const char* s);
@@ -194,7 +194,7 @@ public:
   struct IntegrityCheckSetMap: public std::map<cmStdString, IntegrityCheckSet>
   {};
   std::map<cmStdString, IntegrityCheckSetMap> &GetIntegrityCheckSet() 
-  { return m_CheckDependFiles;}
+  { return this->CheckDependFiles;}
   
   void AppendGlobalTargetDepends(std::vector<std::string>& depends,
                                  cmTarget& target);
@@ -203,11 +203,11 @@ public:
   void WriteLocalAllRules(std::ostream& ruleFileStream);
   
   std::map<cmStdString,std::vector<cmTarget *> > GetLocalObjectFiles()
-    { return m_LocalObjectFiles;}
+    { return this->LocalObjectFiles;}
 
 protected:
-  // these two methods just compute reasonable values for m_LibraryOutputPath
-  // and m_ExecutableOutputPath
+  // these two methods just compute reasonable values for LibraryOutputPath
+  // and ExecutableOutputPath
   void ConfigureOutputPaths();
   void FormatOutputPath(std::string& path, const char* name);
 
@@ -282,33 +282,33 @@ private:
   friend class cmMakefileLibraryTargetGenerator;
   friend class cmMakefileUtilityTargetGenerator;
   
-  std::map<cmStdString, IntegrityCheckSetMap> m_CheckDependFiles;
+  std::map<cmStdString, IntegrityCheckSetMap> CheckDependFiles;
 
   //==========================================================================
   // Configuration settings.
-  int m_MakefileVariableSize;
-  std::string m_IncludeDirective;
-  std::string m_MakeSilentFlag;
-  std::string m_ExecutableOutputPath;
-  std::string m_LibraryOutputPath;
-  std::string m_ConfigurationName;
-  bool m_DefineWindowsNULL;
-  bool m_UnixCD;
-  bool m_PassMakeflags;
-  bool m_SilentNoColon;
+  int MakefileVariableSize;
+  std::string IncludeDirective;
+  std::string MakeSilentFlag;
+  std::string ExecutableOutputPath;
+  std::string LibraryOutputPath;
+  std::string ConfigurationName;
+  bool DefineWindowsNULL;
+  bool UnixCD;
+  bool PassMakeflags;
+  bool SilentNoColon;
   // Flag for whether echo command needs quotes.
-  bool m_EchoNeedsQuote;
+  bool EchoNeedsQuote;
   //==========================================================================
 
-  std::string m_HomeRelativeOutputPath;
+  std::string HomeRelativeOutputPath;
   
-  std::map<cmStdString,std::vector<cmTarget *> > m_LocalObjectFiles;
+  std::map<cmStdString,std::vector<cmTarget *> > LocalObjectFiles;
 
   /* does the work for each target */
   std::vector<cmMakefileTargetGenerator *> TargetGenerators;
-  std::map<cmStdString, cmStdString> m_MakeVariableMap;
-  std::map<cmStdString, cmStdString> m_ShortMakeVariableMap;
-  std::map<cmStdString, cmStdString> m_UniqueObjectNamesMap;
+  std::map<cmStdString, cmStdString> MakeVariableMap;
+  std::map<cmStdString, cmStdString> ShortMakeVariableMap;
+  std::map<cmStdString, cmStdString> UniqueObjectNamesMap;
 };
 
 #endif
diff --git a/Source/cmLocalVisualStudio6Generator.cxx b/Source/cmLocalVisualStudio6Generator.cxx
index cf0cbc2..631b8e6 100644
--- a/Source/cmLocalVisualStudio6Generator.cxx
+++ b/Source/cmLocalVisualStudio6Generator.cxx
@@ -45,13 +45,13 @@ void cmLocalVisualStudio6Generator::Generate()
 void cmLocalVisualStudio6Generator::OutputDSPFile()
 { 
   // If not an in source build, then create the output directory
-  if(strcmp(m_Makefile->GetStartOutputDirectory(),
-            m_Makefile->GetHomeDirectory()) != 0)
+  if(strcmp(this->Makefile->GetStartOutputDirectory(),
+            this->Makefile->GetHomeDirectory()) != 0)
     {
-    if(!cmSystemTools::MakeDirectory(m_Makefile->GetStartOutputDirectory()))
+    if(!cmSystemTools::MakeDirectory(this->Makefile->GetStartOutputDirectory()))
       {
       cmSystemTools::Error("Error creating directory ",
-                           m_Makefile->GetStartOutputDirectory());
+                           this->Makefile->GetStartOutputDirectory());
       }
     }
 
@@ -67,28 +67,29 @@ void cmLocalVisualStudio6Generator::OutputDSPFile()
     std::vector<std::string>::iterator i;
     for(i = includes.begin(); i != includes.end(); ++i)
       {
-      std::string tmp = this->ConvertToOptionallyRelativeOutputPath(i->c_str());
+      std::string tmp = 
+        this->ConvertToOptionallyRelativeOutputPath(i->c_str());
       if(useShortPath)
         {
         cmSystemTools::GetShortPath(tmp.c_str(), tmp);
         }
-      m_IncludeOptions +=  " /I ";
+      this->IncludeOptions +=  " /I ";
 
       // quote if not already quoted
       if (tmp[0] != '"')
         {
-        m_IncludeOptions += "\"";
-        m_IncludeOptions += tmp;
-        m_IncludeOptions += "\"";
+        this->IncludeOptions += "\"";
+        this->IncludeOptions += tmp;
+        this->IncludeOptions += "\"";
         }
       else
         {
-        m_IncludeOptions += tmp;
+        this->IncludeOptions += tmp;
         }
       }
-    if(j == 0 && m_IncludeOptions.size() > maxIncludeLength)
+    if(j == 0 && this->IncludeOptions.size() > maxIncludeLength)
       {
-      m_IncludeOptions = "";
+      this->IncludeOptions = "";
       useShortPath = true;
       }
     else
@@ -100,16 +101,16 @@ void cmLocalVisualStudio6Generator::OutputDSPFile()
   // Create the DSP or set of DSP's for libraries and executables
 
   // clear project names
-  m_CreatedProjectNames.clear();
+  this->CreatedProjectNames.clear();
   // Call TraceVSDependencies on all targets
-  cmTargets &tgts = m_Makefile->GetTargets(); 
+  cmTargets &tgts = this->Makefile->GetTargets(); 
   for(cmTargets::iterator l = tgts.begin(); 
       l != tgts.end(); l++)
     {
     // Add a rule to regenerate the build system when the target
     // specification source changes.
     const char* suppRegenRule =
-      m_Makefile->GetDefinition("CMAKE_SUPPRESS_REGENERATION");
+      this->Makefile->GetDefinition("CMAKE_SUPPRESS_REGENERATION");
     if (!cmSystemTools::IsOn(suppRegenRule))
       {
       this->AddDSPBuildRule(l->second);
@@ -122,13 +123,13 @@ void cmLocalVisualStudio6Generator::OutputDSPFile()
         && (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) != 0))
       {
       cmTarget& target = l->second;
-      target.TraceVSDependencies(target.GetName(), m_Makefile);
+      target.TraceVSDependencies(target.GetName(), this->Makefile);
       }
     }
   // now for all custom commands that are not used directly in a 
   // target, add them to all targets in the current directory or
   // makefile
-  std::vector<cmSourceFile*> & classesmf = m_Makefile->GetSourceFiles();
+  std::vector<cmSourceFile*> & classesmf = this->Makefile->GetSourceFiles();
   for(std::vector<cmSourceFile*>::const_iterator i = classesmf.begin(); 
       i != classesmf.end(); i++)
     {
@@ -204,7 +205,7 @@ void cmLocalVisualStudio6Generator::OutputDSPFile()
       std::string::size_type pos = l->first.rfind('/');
       if(pos != std::string::npos)
         {
-        std::string dir = m_Makefile->GetStartOutputDirectory();
+        std::string dir = this->Makefile->GetStartOutputDirectory();
         dir += "/";
         dir += l->first.substr(0, pos);
         if(!cmSystemTools::MakeDirectory(dir.c_str()))
@@ -221,10 +222,10 @@ void cmLocalVisualStudio6Generator::CreateSingleDSP(const char *lname, cmTarget
 {
   // add to the list of projects
   std::string pname = lname;
-  m_CreatedProjectNames.push_back(pname);
+  this->CreatedProjectNames.push_back(pname);
   // create the dsp.cmake file
   std::string fname;
-  fname = m_Makefile->GetStartOutputDirectory();
+  fname = this->Makefile->GetStartOutputDirectory();
   fname += "/";
   fname += lname;
   fname += ".dsp";
@@ -248,27 +249,27 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt)
 {
   std::string dspname = tgt.GetName();
   dspname += ".dsp.cmake";
-  const char* dsprule = m_Makefile->GetRequiredDefinition("CMAKE_COMMAND");
+  const char* dsprule = this->Makefile->GetRequiredDefinition("CMAKE_COMMAND");
   cmCustomCommandLine commandLine;
   commandLine.push_back(dsprule);
-  std::string makefileIn = m_Makefile->GetStartDirectory();
+  std::string makefileIn = this->Makefile->GetStartDirectory();
   makefileIn += "/";
   makefileIn += "CMakeLists.txt";
   std::string args;
   args = "-H";
   args +=
-    this->Convert(m_Makefile->GetHomeDirectory(),START_OUTPUT, SHELL, true);
+    this->Convert(this->Makefile->GetHomeDirectory(),START_OUTPUT, SHELL, true);
   commandLine.push_back(args);
   args = "-B";
   args += 
-    this->Convert(m_Makefile->GetHomeOutputDirectory(), 
+    this->Convert(this->Makefile->GetHomeOutputDirectory(), 
                   START_OUTPUT, SHELL, true);
   commandLine.push_back(args);
 
   std::string configFile = 
-    m_Makefile->GetRequiredDefinition("CMAKE_ROOT");
+    this->Makefile->GetRequiredDefinition("CMAKE_ROOT");
   configFile += "/Templates/CMakeWindowsSystemConfig.cmake";
-  std::vector<std::string> listFiles = m_Makefile->GetListFiles();
+  std::vector<std::string> listFiles = this->Makefile->GetListFiles();
   bool found = false;
   for(std::vector<std::string>::iterator i = listFiles.begin();
       i != listFiles.end(); ++i)
@@ -287,9 +288,9 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt)
   commandLines.push_back(commandLine);
   const char* no_comment = 0;
   const char* no_working_directory = 0;
-  m_Makefile->AddCustomCommandToOutput(dspname.c_str(), listFiles, makefileIn.c_str(),
+  this->Makefile->AddCustomCommandToOutput(dspname.c_str(), listFiles, makefileIn.c_str(),
                                        commandLines, no_comment, no_working_directory, true);
-  if(cmSourceFile* file = m_Makefile->GetSource(makefileIn.c_str()))
+  if(cmSourceFile* file = this->Makefile->GetSource(makefileIn.c_str()))
     {
     tgt.GetSourceFiles().push_back(file);
     }
@@ -353,7 +354,7 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
   name += ".dsp.cmake";
 
   // We may be modifying the source groups temporarily, so make a copy.
-  std::vector<cmSourceGroup> sourceGroups = m_Makefile->GetSourceGroups();
+  std::vector<cmSourceGroup> sourceGroups = this->Makefile->GetSourceGroups();
   
   // get the classes from the source lists then add them to the groups
   std::vector<cmSourceFile*> & classes = target.GetSourceFiles();
@@ -365,7 +366,7 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
     {
     // Add the file to the list of sources.
     std::string source = (*i)->GetFullPath();
-    cmSourceGroup& sourceGroup = m_Makefile->FindSourceGroup(source.c_str(),
+    cmSourceGroup& sourceGroup = this->Makefile->FindSourceGroup(source.c_str(),
                                                              sourceGroups);
     sourceGroup.AssignSource(*i);
     // while we are at it, if it is a .rule file then for visual studio 6 we
@@ -442,7 +443,7 @@ void cmLocalVisualStudio6Generator::WriteGroup(const cmSourceGroup *sg, cmTarget
       }
 
     const char* lang = 
-      m_GlobalGenerator->GetLanguageFromExtension((*sf)->GetSourceExtension().c_str());
+      this->GlobalGenerator->GetLanguageFromExtension((*sf)->GetSourceExtension().c_str());
     if(lang && strcmp(lang, "CXX") == 0)
       {
       // force a C++ file type
@@ -492,9 +493,9 @@ void cmLocalVisualStudio6Generator::WriteGroup(const cmSourceGroup *sg, cmTarget
       else if(compileFlags.size())
         {
         for(std::vector<std::string>::iterator i
-              = m_Configurations.begin(); i != m_Configurations.end(); ++i)
+              = this->Configurations.begin(); i != this->Configurations.end(); ++i)
           { 
-          if (i == m_Configurations.begin())
+          if (i == this->Configurations.begin())
             {
             fout << "!IF  \"$(CFG)\" == " << i->c_str() << std::endl;
             }
@@ -536,14 +537,14 @@ cmLocalVisualStudio6Generator
                         const cmCustomCommand& origCommand)
 {
   // Create a fake output that forces the rule to run.
-  char* output = new char[(strlen(m_Makefile->GetStartOutputDirectory()) +
+  char* output = new char[(strlen(this->Makefile->GetStartOutputDirectory()) +
                            strlen(target.GetName()) + 30)];
-  sprintf(output,"%s/%s_force_%i", m_Makefile->GetStartOutputDirectory(),
+  sprintf(output,"%s/%s_force_%i", this->Makefile->GetStartOutputDirectory(),
           target.GetName(), count);
 
   // Add the rule with the given dependencies and commands.
   const char* no_main_dependency = 0;
-  m_Makefile->AddCustomCommandToOutput(output,
+  this->Makefile->AddCustomCommandToOutput(output,
                                        depends,
                                        no_main_dependency,
                                        origCommand.GetCommandLines(),
@@ -556,7 +557,7 @@ cmLocalVisualStudio6Generator
   depends.push_back(output);
 
   // Add a source file representing this output to the project.
-  cmSourceFile* outsf = m_Makefile->GetSourceFileWithOutput(output);
+  cmSourceFile* outsf = this->Makefile->GetSourceFileWithOutput(output);
   target.GetSourceFiles().push_back(outsf);
 
   // Free the fake output name.
@@ -573,9 +574,9 @@ void cmLocalVisualStudio6Generator::WriteCustomRule(std::ostream& fout,
   )
 {
   std::vector<std::string>::iterator i;
-  for(i = m_Configurations.begin(); i != m_Configurations.end(); ++i)
+  for(i = this->Configurations.begin(); i != this->Configurations.end(); ++i)
     {
-    if (i == m_Configurations.begin())
+    if (i == this->Configurations.begin())
       {
       fout << "!IF  \"$(CFG)\" == " << i->c_str() << std::endl;
       }
@@ -640,8 +641,8 @@ void cmLocalVisualStudio6Generator::SetBuildType(BuildType b,
                                                  const char* libName,
                                                  cmTarget& target)
 {
-  std::string root= m_Makefile->GetRequiredDefinition("CMAKE_ROOT");
-  const char *def= m_Makefile->GetDefinition( "MSPROJECT_TEMPLATE_DIRECTORY");
+  std::string root= this->Makefile->GetRequiredDefinition("CMAKE_ROOT");
+  const char *def= this->Makefile->GetDefinition( "MSPROJECT_TEMPLATE_DIRECTORY");
 
   if( def)
     {
@@ -655,53 +656,53 @@ void cmLocalVisualStudio6Generator::SetBuildType(BuildType b,
   switch(b)
     {
     case STATIC_LIBRARY:
-      m_DSPHeaderTemplate = root;
-      m_DSPHeaderTemplate += "/staticLibHeader.dsptemplate";
-      m_DSPFooterTemplate = root;
-      m_DSPFooterTemplate += "/staticLibFooter.dsptemplate";
+      this->DSPHeaderTemplate = root;
+      this->DSPHeaderTemplate += "/staticLibHeader.dsptemplate";
+      this->DSPFooterTemplate = root;
+      this->DSPFooterTemplate += "/staticLibFooter.dsptemplate";
       break;
     case DLL:
-      m_DSPHeaderTemplate =  root;
-      m_DSPHeaderTemplate += "/DLLHeader.dsptemplate";
-      m_DSPFooterTemplate =  root;
-      m_DSPFooterTemplate += "/DLLFooter.dsptemplate";
+      this->DSPHeaderTemplate =  root;
+      this->DSPHeaderTemplate += "/DLLHeader.dsptemplate";
+      this->DSPFooterTemplate =  root;
+      this->DSPFooterTemplate += "/DLLFooter.dsptemplate";
       break;
     case EXECUTABLE:
       if ( target.GetPropertyAsBool("WIN32_EXECUTABLE") )
         {
-        m_DSPHeaderTemplate = root;
-        m_DSPHeaderTemplate += "/EXEWinHeader.dsptemplate";
-        m_DSPFooterTemplate = root;
-        m_DSPFooterTemplate += "/EXEFooter.dsptemplate";
+        this->DSPHeaderTemplate = root;
+        this->DSPHeaderTemplate += "/EXEWinHeader.dsptemplate";
+        this->DSPFooterTemplate = root;
+        this->DSPFooterTemplate += "/EXEFooter.dsptemplate";
         }
       else
         {
-        m_DSPHeaderTemplate = root;
-        m_DSPHeaderTemplate += "/EXEHeader.dsptemplate";
-        m_DSPFooterTemplate = root;
-        m_DSPFooterTemplate += "/EXEFooter.dsptemplate";
+        this->DSPHeaderTemplate = root;
+        this->DSPHeaderTemplate += "/EXEHeader.dsptemplate";
+        this->DSPFooterTemplate = root;
+        this->DSPFooterTemplate += "/EXEFooter.dsptemplate";
         }
       break;
     case UTILITY:
-      m_DSPHeaderTemplate = root;
-      m_DSPHeaderTemplate += "/UtilityHeader.dsptemplate";
-      m_DSPFooterTemplate = root;
-      m_DSPFooterTemplate += "/UtilityFooter.dsptemplate";
+      this->DSPHeaderTemplate = root;
+      this->DSPHeaderTemplate += "/UtilityHeader.dsptemplate";
+      this->DSPFooterTemplate = root;
+      this->DSPFooterTemplate += "/UtilityFooter.dsptemplate";
       break;
     }
 
   // once the build type is set, determine what configurations are
   // possible
-  std::ifstream fin(m_DSPHeaderTemplate.c_str());
+  std::ifstream fin(this->DSPHeaderTemplate.c_str());
 
   cmsys::RegularExpression reg("# Name ");
   if(!fin)
     {
-    cmSystemTools::Error("Error Reading ", m_DSPHeaderTemplate.c_str());
+    cmSystemTools::Error("Error Reading ", this->DSPHeaderTemplate.c_str());
     }
 
-  // reset m_Configurations
-  m_Configurations.erase(m_Configurations.begin(), m_Configurations.end());
+  // reset this->Configurations
+  this->Configurations.erase(this->Configurations.begin(), this->Configurations.end());
   // now add all the configurations possible
   std::string line;
   while(cmSystemTools::GetLineFromStream(fin, line))
@@ -709,7 +710,7 @@ void cmLocalVisualStudio6Generator::SetBuildType(BuildType b,
     cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME",libName);
     if (reg.find(line))
       {
-      m_Configurations.push_back(line.substr(reg.end()));
+      this->Configurations.push_back(line.substr(reg.end()));
       }
     }
 }
@@ -837,14 +838,14 @@ void cmLocalVisualStudio6Generator
 
   // suppoirt override in output directory
   std::string libPath = "";
-  if (m_Makefile->GetDefinition("LIBRARY_OUTPUT_PATH"))
+  if (this->Makefile->GetDefinition("LIBRARY_OUTPUT_PATH"))
     {
-    libPath = m_Makefile->GetDefinition("LIBRARY_OUTPUT_PATH");
+    libPath = this->Makefile->GetDefinition("LIBRARY_OUTPUT_PATH");
     }
   std::string exePath = "";
-  if (m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
+  if (this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
     {
-    exePath = m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH");
+    exePath = this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH");
     
     }
   if(libPath.size())
@@ -963,8 +964,8 @@ void cmLocalVisualStudio6Generator
       }
     }
   // find link libraries
-  const cmTarget::LinkLibraries& libs = target.GetLinkLibraries();
-  cmTarget::LinkLibraries::const_iterator j;
+  const cmTarget::LinkLibraryVectorType& libs = target.GetLinkLibraries();
+  cmTarget::LinkLibraryVectorType::const_iterator j;
   for(j = libs.begin(); j != libs.end(); ++j)
     {
     // add libraries to executables and dlls (but never include
@@ -979,7 +980,7 @@ void cmLocalVisualStudio6Generator
       // Compute the proper name to use to link this library.
       std::string lib;
       std::string libDebug;
-      cmTarget* tgt = m_GlobalGenerator->FindTarget(0, j->first.c_str());
+      cmTarget* tgt = this->GlobalGenerator->FindTarget(0, j->first.c_str());
       if(tgt)
         {
         lib = cmSystemTools::GetFilenameWithoutExtension(tgt->GetFullName().c_str());
@@ -1042,7 +1043,7 @@ void cmLocalVisualStudio6Generator
   if(target.GetType() == cmTarget::EXECUTABLE)
     {
     extraLinkOptions = 
-      m_Makefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS");
+      this->Makefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS");
 
     // Use the OUTPUT_NAME property if it was set.  This is supported
     // only for executables.
@@ -1058,11 +1059,11 @@ void cmLocalVisualStudio6Generator
     }
   if(target.GetType() == cmTarget::SHARED_LIBRARY)
     {
-    extraLinkOptions = m_Makefile->GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS");
+    extraLinkOptions = this->Makefile->GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS");
     }
   if(target.GetType() == cmTarget::MODULE_LIBRARY)
     {
-    extraLinkOptions = m_Makefile->GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS");
+    extraLinkOptions = this->Makefile->GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS");
     }
 
   if(extraLinkOptions.size())
@@ -1077,7 +1078,7 @@ void cmLocalVisualStudio6Generator
     libMultiLineOptionsForDebug +=  extraLinkOptions;
     libMultiLineOptionsForDebug += " \n";
     }
-  if(const char* stdLibs =  m_Makefile->GetDefinition("CMAKE_STANDARD_LIBRARIES"))
+  if(const char* stdLibs =  this->Makefile->GetDefinition("CMAKE_STANDARD_LIBRARIES"))
     {
     libOptions += " ";
     libOptions += stdLibs;
@@ -1107,10 +1108,10 @@ void cmLocalVisualStudio6Generator
   // only if the target is a lib or exe
   std::string customRuleCode = this->CreateTargetRules(target, libName);
 
-  std::ifstream fin(m_DSPHeaderTemplate.c_str());
+  std::ifstream fin(this->DSPHeaderTemplate.c_str());
   if(!fin)
     {
-    cmSystemTools::Error("Error Reading ", m_DSPHeaderTemplate.c_str());
+    cmSystemTools::Error("Error Reading ", this->DSPHeaderTemplate.c_str());
     }
   std::string staticLibOptions;
   if(target.GetType() == cmTarget::STATIC_LIBRARY )
@@ -1136,7 +1137,7 @@ void cmLocalVisualStudio6Generator
   std::string line;
   while(cmSystemTools::GetLineFromStream(fin, line))
     {
-    const char* mfcFlag = m_Makefile->GetDefinition("CMAKE_MFC_FLAG");
+    const char* mfcFlag = this->Makefile->GetDefinition("CMAKE_MFC_FLAG");
     if(!mfcFlag)
       {
       mfcFlag = "0";
@@ -1152,7 +1153,7 @@ void cmLocalVisualStudio6Generator
       cmSystemTools::ReplaceString(line, "CM_STATIC_LIB_ARGS",
                                    staticLibOptions.c_str());
       } 
-    if(m_Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
+    if(this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
       {
       cmSystemTools::ReplaceString(line, "/nologo", "");
       }
@@ -1178,7 +1179,7 @@ void cmLocalVisualStudio6Generator
     cmSystemTools::ReplaceString(line, "OUTPUT_NAME", outputName.c_str());
 
     cmSystemTools::ReplaceString(line, "BUILD_INCLUDES",
-                                 m_IncludeOptions.c_str());
+                                 this->IncludeOptions.c_str());
     cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME",libName);
     // because LIBRARY_OUTPUT_PATH and EXECUTABLE_OUTPUT_PATH 
     // are already quoted in the template file,
@@ -1194,9 +1195,9 @@ void cmLocalVisualStudio6Generator
 
     cmSystemTools::ReplaceString(line, 
                                  "EXTRA_DEFINES", 
-                                 m_Makefile->GetDefineFlags());
+                                 this->Makefile->GetDefineFlags());
     const char* debugPostfix
-      = m_Makefile->GetDefinition("CMAKE_DEBUG_POSTFIX");
+      = this->Makefile->GetDefinition("CMAKE_DEBUG_POSTFIX");
     cmSystemTools::ReplaceString(line, "DEBUG_POSTFIX", 
                                  debugPostfix?debugPostfix:"");
     // store flags for each configuration
@@ -1219,27 +1220,27 @@ void cmLocalVisualStudio6Generator
       std::string baseFlagVar = "CMAKE_";
       baseFlagVar += linkLanguage;
       baseFlagVar += "_FLAGS";
-      flags = m_Makefile->GetRequiredDefinition(baseFlagVar.c_str());
+      flags = this->Makefile->GetRequiredDefinition(baseFlagVar.c_str());
       
       std::string flagVar = baseFlagVar + "_RELEASE";
-      flagsRelease = m_Makefile->GetRequiredDefinition(flagVar.c_str());
+      flagsRelease = this->Makefile->GetRequiredDefinition(flagVar.c_str());
       flagsRelease += " -DCMAKE_INTDIR=\\\"Release\\\" ";
       
       flagVar = baseFlagVar + "_MINSIZEREL";
-      flagsMinSize = m_Makefile->GetRequiredDefinition(flagVar.c_str());
+      flagsMinSize = this->Makefile->GetRequiredDefinition(flagVar.c_str());
       flagsMinSize += " -DCMAKE_INTDIR=\\\"MinSizeRel\\\" ";
       
       flagVar = baseFlagVar + "_DEBUG";
-      flagsDebug = m_Makefile->GetRequiredDefinition(flagVar.c_str());
+      flagsDebug = this->Makefile->GetRequiredDefinition(flagVar.c_str());
       flagsDebug += " -DCMAKE_INTDIR=\\\"Debug\\\" ";
       
       flagVar = baseFlagVar + "_RELWITHDEBINFO";
-      flagsDebugRel = m_Makefile->GetRequiredDefinition(flagVar.c_str());
+      flagsDebugRel = this->Makefile->GetRequiredDefinition(flagVar.c_str());
       flagsDebugRel += " -DCMAKE_INTDIR=\\\"RelWithDebInfo\\\" ";
       }
     
     // if unicode is not found, then add -D_MBCS
-    std::string defs = m_Makefile->GetDefineFlags();
+    std::string defs = this->Makefile->GetDefineFlags();
     if(flags.find("D_UNICODE") == flags.npos &&
        defs.find("D_UNICODE") == flags.npos) 
       {
@@ -1268,11 +1269,11 @@ void cmLocalVisualStudio6Generator
 
 void cmLocalVisualStudio6Generator::WriteDSPFooter(std::ostream& fout)
 {  
-  std::ifstream fin(m_DSPFooterTemplate.c_str());
+  std::ifstream fin(this->DSPFooterTemplate.c_str());
   if(!fin)
     {
     cmSystemTools::Error("Error Reading ",
-                         m_DSPFooterTemplate.c_str());
+                         this->DSPFooterTemplate.c_str());
     }
   std::string line;
   while(cmSystemTools::GetLineFromStream(fin, line))
diff --git a/Source/cmLocalVisualStudio6Generator.h b/Source/cmLocalVisualStudio6Generator.h
index f0067cb..a1450b3 100644
--- a/Source/cmLocalVisualStudio6Generator.h
+++ b/Source/cmLocalVisualStudio6Generator.h
@@ -29,7 +29,7 @@ class cmCustomCommand;
  * \brief Write a LocalUnix makefiles.
  *
  * cmLocalVisualStudio6Generator produces a LocalUnix makefile from its
- * member m_Makefile.
+ * member this->Makefile.
  */
 class cmLocalVisualStudio6Generator : public cmLocalGenerator
 {
@@ -59,13 +59,13 @@ public:
    */
   std::vector<std::string> GetCreatedProjectNames() 
     {
-    return m_CreatedProjectNames;
+    return this->CreatedProjectNames;
     }
 
 private:
-  std::string m_DSPHeaderTemplate;
-  std::string m_DSPFooterTemplate;
-  std::vector<std::string> m_CreatedProjectNames;
+  std::string DSPHeaderTemplate;
+  std::string DSPFooterTemplate;
+  std::vector<std::string> CreatedProjectNames;
   
   void CreateSingleDSP(const char *lname, cmTarget &tgt);
   void WriteDSPFile(std::ostream& fout, const char *libName, 
@@ -94,8 +94,8 @@ private:
                   std::ostream &fout, const char *libName);
   std::string CreateTargetRules(cmTarget &target, 
                                 const char *libName);
-  std::string m_IncludeOptions;
-  std::vector<std::string> m_Configurations;
+  std::string IncludeOptions;
+  std::vector<std::string> Configurations;
 };
 
 #endif
diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx
index e6b5a59..c1eaa77 100644
--- a/Source/cmLocalVisualStudio7Generator.cxx
+++ b/Source/cmLocalVisualStudio7Generator.cxx
@@ -24,7 +24,7 @@
 
 cmLocalVisualStudio7Generator::cmLocalVisualStudio7Generator()
 {
-  m_Version = 7;
+  this->Version = 7;
 }
 
 cmLocalVisualStudio7Generator::~cmLocalVisualStudio7Generator()
@@ -50,61 +50,62 @@ void cmLocalVisualStudio7Generator::Generate()
 void cmLocalVisualStudio7Generator::OutputVCProjFile()
 {
   // If not an in source build, then create the output directory
-  if(strcmp(m_Makefile->GetStartOutputDirectory(),
-            m_Makefile->GetHomeDirectory()) != 0)
+  if(strcmp(this->Makefile->GetStartOutputDirectory(),
+            this->Makefile->GetHomeDirectory()) != 0)
     {
-    if(!cmSystemTools::MakeDirectory(m_Makefile->GetStartOutputDirectory()))
+    if(!cmSystemTools::MakeDirectory(this->Makefile->GetStartOutputDirectory()))
       {
       cmSystemTools::Error("Error creating directory ",
-                           m_Makefile->GetStartOutputDirectory());
+                           this->Makefile->GetStartOutputDirectory());
       }
     }
 
-  m_LibraryOutputPath = "";
-  if (m_Makefile->GetDefinition("LIBRARY_OUTPUT_PATH"))
+  this->LibraryOutputPath = "";
+  if (this->Makefile->GetDefinition("LIBRARY_OUTPUT_PATH"))
     {
-    m_LibraryOutputPath = m_Makefile->GetDefinition("LIBRARY_OUTPUT_PATH");
+    this->LibraryOutputPath = 
+      this->Makefile->GetDefinition("LIBRARY_OUTPUT_PATH");
     }
-  if(m_LibraryOutputPath.size())
+  if(this->LibraryOutputPath.size())
     {
     // make sure there is a trailing slash
-    if(m_LibraryOutputPath[m_LibraryOutputPath.size()-1] != '/')
+    if(this->LibraryOutputPath[this->LibraryOutputPath.size()-1] != '/')
       {
-      m_LibraryOutputPath += "/";
+      this->LibraryOutputPath += "/";
       }
     }
-  m_ExecutableOutputPath = "";
-  if (m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
+  this->ExecutableOutputPath = "";
+  if (this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
     {
-    m_ExecutableOutputPath = m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH");
+    this->ExecutableOutputPath = this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH");
     }
-  if(m_ExecutableOutputPath.size())
+  if(this->ExecutableOutputPath.size())
     {
     // make sure there is a trailing slash
-    if(m_ExecutableOutputPath[m_ExecutableOutputPath.size()-1] != '/')
+    if(this->ExecutableOutputPath[this->ExecutableOutputPath.size()-1] != '/')
       {
-      m_ExecutableOutputPath += "/";
+      this->ExecutableOutputPath += "/";
       }
     }
 
   // Create the VCProj or set of VCProj's for libraries and executables
 
   // clear project names
-  m_CreatedProjectNames.clear();
+  this->CreatedProjectNames.clear();
 
 #if 1
   // TODO: This block should be moved to a central location for all
   // generators.  It is duplicated in every generator.
 
   // Call TraceVSDependencies on all targets
-  cmTargets &tgts = m_Makefile->GetTargets();
+  cmTargets &tgts = this->Makefile->GetTargets();
   for(cmTargets::iterator l = tgts.begin();
       l != tgts.end(); l++)
     {
     // Add a rule to regenerate the build system when the target
     // specification source changes.
     const char* suppRegenRule =
-      m_Makefile->GetDefinition("CMAKE_SUPPRESS_REGENERATION");
+      this->Makefile->GetDefinition("CMAKE_SUPPRESS_REGENERATION");
     if (!cmSystemTools::IsOn(suppRegenRule) &&
         (strcmp(l->first.c_str(), CMAKE_CHECK_BUILD_SYSTEM_TARGET) != 0))
       {
@@ -118,13 +119,13 @@ void cmLocalVisualStudio7Generator::OutputVCProjFile()
         && (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) != 0))
       {
       cmTarget& target = l->second;
-      target.TraceVSDependencies(target.GetName(), m_Makefile);
+      target.TraceVSDependencies(target.GetName(), this->Makefile);
       }
     }
   // now for all custom commands that are not used directly in a
   // target, add them to all targets in the current directory or
   // makefile
-  std::vector<cmSourceFile*> & classesmf = m_Makefile->GetSourceFiles();
+  std::vector<cmSourceFile*> & classesmf = this->Makefile->GetSourceFiles();
   for(std::vector<cmSourceFile*>::const_iterator i = classesmf.begin();
       i != classesmf.end(); i++)
     {
@@ -203,10 +204,10 @@ void cmLocalVisualStudio7Generator::CreateSingleVCProj(const char *lname, cmTarg
 {
   // add to the list of projects
   std::string pname = lname;
-  m_CreatedProjectNames.push_back(pname);
+  this->CreatedProjectNames.push_back(pname);
   // create the dsp.cmake file
   std::string fname;
-  fname = m_Makefile->GetStartOutputDirectory();
+  fname = this->Makefile->GetStartOutputDirectory();
   fname += "/";
   fname += lname;
   fname += ".vcproj";
@@ -229,27 +230,27 @@ void cmLocalVisualStudio7Generator::AddVCProjBuildRule(cmTarget& tgt)
 {
   std::string dspname = tgt.GetName();
   dspname += ".vcproj.cmake";
-  const char* dsprule = m_Makefile->GetRequiredDefinition("CMAKE_COMMAND");
+  const char* dsprule = this->Makefile->GetRequiredDefinition("CMAKE_COMMAND");
   cmCustomCommandLine commandLine;
   commandLine.push_back(dsprule);
-  std::string makefileIn = m_Makefile->GetStartDirectory();
+  std::string makefileIn = this->Makefile->GetStartDirectory();
   makefileIn += "/";
   makefileIn += "CMakeLists.txt";
   std::string args;
   args = "-H";
   args +=
-    this->Convert(m_Makefile->GetHomeDirectory(), START_OUTPUT, SHELL, true);
+    this->Convert(this->Makefile->GetHomeDirectory(), START_OUTPUT, SHELL, true);
   commandLine.push_back(args);
   args = "-B";
   args +=
-    this->Convert(m_Makefile->GetHomeOutputDirectory(),
+    this->Convert(this->Makefile->GetHomeOutputDirectory(),
                   START_OUTPUT, SHELL, true);
   commandLine.push_back(args);
 
   std::string configFile =
-    m_Makefile->GetRequiredDefinition("CMAKE_ROOT");
+    this->Makefile->GetRequiredDefinition("CMAKE_ROOT");
   configFile += "/Templates/CMakeWindowsSystemConfig.cmake";
-  std::vector<std::string> listFiles = m_Makefile->GetListFiles();
+  std::vector<std::string> listFiles = this->Makefile->GetListFiles();
   bool found = false;
   for(std::vector<std::string>::iterator i = listFiles.begin();
       i != listFiles.end(); ++i)
@@ -268,9 +269,9 @@ void cmLocalVisualStudio7Generator::AddVCProjBuildRule(cmTarget& tgt)
   commandLines.push_back(commandLine);
   const char* no_working_directory = 0;
   const char* no_comment = 0;
-  m_Makefile->AddCustomCommandToOutput(dspname.c_str(), listFiles, makefileIn.c_str(),
+  this->Makefile->AddCustomCommandToOutput(dspname.c_str(), listFiles, makefileIn.c_str(),
                                        commandLines, no_comment, no_working_directory, true);
-  if(cmSourceFile* file = m_Makefile->GetSource(makefileIn.c_str()))
+  if(cmSourceFile* file = this->Makefile->GetSource(makefileIn.c_str()))
     {
     tgt.GetSourceFiles().push_back(file);
     }
@@ -286,7 +287,7 @@ void cmLocalVisualStudio7Generator::WriteConfigurations(std::ostream& fout,
                                                         cmTarget &target)
 {
   std::vector<std::string> *configs =
-    static_cast<cmGlobalVisualStudio7Generator *>(m_GlobalGenerator)->GetConfigurations();
+    static_cast<cmGlobalVisualStudio7Generator *>(this->GlobalGenerator)->GetConfigurations();
   fout << "\t<Configurations>\n";
   for( std::vector<std::string>::iterator i = configs->begin();
        i != configs->end(); ++i)
@@ -403,7 +404,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
   // in the flags it will be turned on and we have /EHSC on by
   // default in the CXX flags, then this is the only way to turn this off
   flagMap["ExceptionHandling"] = "FALSE";
-  const char* mfcFlag = m_Makefile->GetDefinition("CMAKE_MFC_FLAG");
+  const char* mfcFlag = this->Makefile->GetDefinition("CMAKE_MFC_FLAG");
   if(!mfcFlag)
     {
     mfcFlag = "0";
@@ -451,11 +452,11 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
       std::string baseFlagVar = "CMAKE_";
       baseFlagVar += linkLanguage;
       baseFlagVar += "_FLAGS";
-      flags = m_Makefile->GetRequiredDefinition(baseFlagVar.c_str());
+      flags = this->Makefile->GetRequiredDefinition(baseFlagVar.c_str());
       std::string flagVar = baseFlagVar + std::string("_") +
         cmSystemTools::UpperCase(configName);
       flags += " ";
-      flags += m_Makefile->GetRequiredDefinition(flagVar.c_str());
+      flags += this->Makefile->GetRequiredDefinition(flagVar.c_str());
       }
     }
 
@@ -480,7 +481,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
   // if -D_UNICODE or /D_UNICODE is found in the flags
   // change the character set to unicode, if not then
   // default to MBCS
-  std::string defs = m_Makefile->GetDefineFlags();
+  std::string defs = this->Makefile->GetDefineFlags();
   if(flags.find("D_UNICODE") != flags.npos ||
      defs.find("D_UNICODE") != flags.npos)
     {
@@ -500,7 +501,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
   this->FillFlagMapFromCommandFlags(flagMap,
                                     &cmLocalVisualStudio7GeneratorFlagTable[0],
                                     flags);
-  std::string defineFlags = m_Makefile->GetDefineFlags();
+  std::string defineFlags = this->Makefile->GetDefineFlags();
   // now check the define flags for flags other than -D and
   // put them in the map, the -D flags will be left in the defineFlags
   // variable as -D is not in the flagMap
@@ -522,13 +523,13 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
     }
   fout << "\"\n";
   // set a few cmake specific flags
-  if(m_Makefile->IsOn("CMAKE_CXX_USE_RTTI"))
+  if(this->Makefile->IsOn("CMAKE_CXX_USE_RTTI"))
     {
     flagMap["RuntimeTypeInfo"] = "TRUE";
     }
-  if ( m_Makefile->GetDefinition("CMAKE_CXX_WARNING_LEVEL") )
+  if ( this->Makefile->GetDefinition("CMAKE_CXX_WARNING_LEVEL") )
     {
-    flagMap["WarningLevel"] = m_Makefile->GetDefinition("CMAKE_CXX_WARNING_LEVEL");
+    flagMap["WarningLevel"] = this->Makefile->GetDefinition("CMAKE_CXX_WARNING_LEVEL");
     }
 
   // Now copy the flag map into the xml for the file
@@ -542,7 +543,8 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
      || target.GetType() == cmTarget::MODULE_LIBRARY)
     {
     std::string exportSymbol;
-    if (const char* custom_export_name = target.GetProperty("DEFINE_SYMBOL"))
+    if (const char* custom_export_name = 
+        target.GetProperty("DEFINE_SYMBOL"))
       {
       exportSymbol = custom_export_name;
       }
@@ -562,7 +564,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
   if(mi != flagMap.end() && mi->second != "1")
     {
     fout <<  "\t\t\t\tProgramDatabaseFileName=\""
-         << m_LibraryOutputPath
+         << this->LibraryOutputPath
          << "$(OutDir)/" << libName << ".pdb\"\n";
     }
   fout << "/>\n";  // end of <Tool Name=VCCLCompilerTool
@@ -637,7 +639,7 @@ void cmLocalVisualStudio7Generator::FillFlagMapFromCommandFlags(
   // was not given explicitly in the flags we want to add an attribute
   // to the generated project to disable logo suppression.  Otherwise
   // the GUI default is to enable suppression.
-  if(m_Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
+  if(this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
     {
     if(flagMap.find("SuppressStartupBanner") == flagMap.end())
       {
@@ -655,7 +657,7 @@ cmLocalVisualStudio7Generator
   std::string extraLinkOptionsBuildTypeDef = rootLinkerFlags + "_" + configTypeUpper;
 
   std::string extraLinkOptionsBuildType =
-    m_Makefile->GetRequiredDefinition(extraLinkOptionsBuildTypeDef.c_str());
+    this->Makefile->GetRequiredDefinition(extraLinkOptionsBuildTypeDef.c_str());
 
   return extraLinkOptionsBuildType;
 }
@@ -670,17 +672,17 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
   std::string extraLinkOptions;
   if(target.GetType() == cmTarget::EXECUTABLE)
     {
-    extraLinkOptions = m_Makefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS") +
+    extraLinkOptions = this->Makefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS") +
       std::string(" ") + GetBuildTypeLinkerFlags("CMAKE_EXE_LINKER_FLAGS", configName);
     }
   if(target.GetType() == cmTarget::SHARED_LIBRARY)
     {
-    extraLinkOptions = m_Makefile->GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS") +
+    extraLinkOptions = this->Makefile->GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS") +
       std::string(" ") + GetBuildTypeLinkerFlags("CMAKE_SHARED_LINKER_FLAGS", configName);
     }
   if(target.GetType() == cmTarget::MODULE_LIBRARY)
     {
-    extraLinkOptions = m_Makefile->GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS") +
+    extraLinkOptions = this->Makefile->GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS") +
       std::string(" ") + GetBuildTypeLinkerFlags("CMAKE_MODULE_LINKER_FLAGS", configName);
     }
 
@@ -700,7 +702,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
     {
     case cmTarget::STATIC_LIBRARY:
     {
-    std::string libpath = m_LibraryOutputPath +
+    std::string libpath = this->LibraryOutputPath +
       "$(OutDir)/" + targetFullName;
     fout << "\t\t\t<Tool\n"
          << "\t\t\t\tName=\"VCLibrarianTool\"\n";
@@ -732,11 +734,11 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
     // libraries which may be set by the user to something bad.
     fout << "\"\n"
          << "\t\t\t\tAdditionalDependencies=\"$(NOINHERIT) "
-         << m_Makefile->GetRequiredDefinition("CMAKE_STANDARD_LIBRARIES")
+         << this->Makefile->GetRequiredDefinition("CMAKE_STANDARD_LIBRARIES")
          << " ";
     this->OutputLibraries(fout, linkLibs);
     fout << "\"\n";
-    temp = m_LibraryOutputPath;
+    temp = this->LibraryOutputPath;
     temp += configName;
     temp += "/";
     temp += targetFullName;
@@ -751,7 +753,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
     this->OutputLibraryDirectories(fout, linkDirs);
     fout << "\"\n";
     this->OutputModuleDefinitionFile(fout, target);
-    temp = m_LibraryOutputPath;
+    temp = this->LibraryOutputPath;
     temp += "$(OutDir)/";
     temp += libName;
     temp += ".pdb";
@@ -772,12 +774,12 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
     std::string stackVar = "CMAKE_";
     stackVar += linkLanguage;
     stackVar += "_STACK_SIZE";
-    const char* stackVal = m_Makefile->GetDefinition(stackVar.c_str());
+    const char* stackVal = this->Makefile->GetDefinition(stackVar.c_str());
     if(stackVal)
       {
       fout << "\t\t\t\tStackReserveSize=\"" << stackVal  << "\"\n";
       }
-    temp = m_LibraryOutputPath;
+    temp = this->LibraryOutputPath;
     temp += configName;
     temp += "/";
     temp += cmSystemTools::GetFilenameWithoutLastExtension(targetFullName.c_str());
@@ -804,11 +806,11 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
     // libraries which may be set by the user to something bad.
     fout << "\"\n"
          << "\t\t\t\tAdditionalDependencies=\"$(NOINHERIT) "
-         << m_Makefile->GetRequiredDefinition("CMAKE_STANDARD_LIBRARIES")
+         << this->Makefile->GetRequiredDefinition("CMAKE_STANDARD_LIBRARIES")
          << " ";
     this->OutputLibraries(fout, linkLibs);
     fout << "\"\n";
-    temp = m_ExecutableOutputPath;
+    temp = this->ExecutableOutputPath;
     temp += configName;
     temp += "/";
     temp += targetFullName;
@@ -821,7 +823,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
     fout << "\t\t\t\tAdditionalLibraryDirectories=\"";
     this->OutputLibraryDirectories(fout, linkDirs);
     fout << "\"\n";
-    fout << "\t\t\t\tProgramDatabaseFile=\"" << m_LibraryOutputPath
+    fout << "\t\t\t\tProgramDatabaseFile=\"" << this->LibraryOutputPath
          << "$(OutDir)\\" << libName << ".pdb\"\n";
     if(strcmp(configName, "Debug") == 0
        || strcmp(configName, "RelWithDebInfo") == 0)
@@ -846,7 +848,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
     std::string stackVar = "CMAKE_";
     stackVar += linkLanguage;
     stackVar += "_STACK_SIZE";
-    const char* stackVal = m_Makefile->GetDefinition(stackVar.c_str());
+    const char* stackVal = this->Makefile->GetDefinition(stackVar.c_str());
     if(stackVal)
       {
       fout << "\t\t\t\tStackReserveSize=\"" << stackVal << "\"";
@@ -962,14 +964,14 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout,
   // get the configurations
   std::vector<std::string> *configs =
     static_cast<cmGlobalVisualStudio7Generator *>
-    (m_GlobalGenerator)->GetConfigurations();
+    (this->GlobalGenerator)->GetConfigurations();
 
   // trace the visual studio dependencies
   std::string name = libName;
   name += ".vcproj.cmake";
 
   // We may be modifying the source groups temporarily, so make a copy.
-  std::vector<cmSourceGroup> sourceGroups = m_Makefile->GetSourceGroups();
+  std::vector<cmSourceGroup> sourceGroups = this->Makefile->GetSourceGroups();
 
   // get the classes from the source lists then add them to the groups
   std::vector<cmSourceFile*> & classes = target.GetSourceFiles();
@@ -980,10 +982,10 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout,
     std::string source = (*i)->GetFullPath();
     if(cmSystemTools::UpperCase((*i)->GetSourceExtension()) == "DEF")
       {
-      m_ModuleDefinitionFile = (*i)->GetFullPath();
+      this->ModuleDefinitionFile = (*i)->GetFullPath();
       }
     cmSourceGroup& sourceGroup =
-      m_Makefile->FindSourceGroup(source.c_str(), sourceGroups);
+      this->Makefile->FindSourceGroup(source.c_str(), sourceGroups);
     sourceGroup.AssignSource(*i);
     }
 
@@ -1044,7 +1046,7 @@ void cmLocalVisualStudio7Generator::WriteGroup(const cmSourceGroup *sg, cmTarget
       compileFlags += cflags;
       }
     const char* lang =
-      m_GlobalGenerator->GetLanguageFromExtension((*sf)->GetSourceExtension().c_str());
+      this->GlobalGenerator->GetLanguageFromExtension((*sf)->GetSourceExtension().c_str());
     if(lang && strcmp(lang, "CXX") == 0)
       {
       // force a C++ file type
@@ -1154,7 +1156,7 @@ WriteCustomRule(std::ostream& fout,
 {
   std::vector<std::string>::iterator i;
   std::vector<std::string> *configs =
-    static_cast<cmGlobalVisualStudio7Generator *>(m_GlobalGenerator)->GetConfigurations();
+    static_cast<cmGlobalVisualStudio7Generator *>(this->GlobalGenerator)->GetConfigurations();
   for(i = configs->begin(); i != configs->end(); ++i)
     {
     fout << "\t\t\t\t<FileConfiguration\n";
@@ -1299,13 +1301,13 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout,
   fout << "<?xml version=\"1.0\" encoding = \"Windows-1252\"?>\n"
        << "<VisualStudioProject\n"
        << "\tProjectType=\"Visual C++\"\n";
-  if(m_Version == 71)
+  if(this->Version == 71)
     {
     fout << "\tVersion=\"7.10\"\n";
     }
   else
     {
-    if (m_Version == 8)
+    if (this->Version == 8)
       {
       fout << "\tVersion=\"8.00\"\n";
       }
@@ -1325,9 +1327,9 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout,
     keyword = "Win32Proj";
     }
   cmGlobalVisualStudio7Generator* gg =
-    static_cast<cmGlobalVisualStudio7Generator *>(m_GlobalGenerator);
+    static_cast<cmGlobalVisualStudio7Generator *>(this->GlobalGenerator);
   fout << "\tName=\"" << projLabel << "\"\n";
-  if(m_Version == 8)
+  if(this->Version == 8)
     {
     fout << "\tProjectGUID=\"{" << gg->GetGUID(libName) << "}\"\n";
     }
@@ -1382,10 +1384,10 @@ std::string cmLocalVisualStudio7Generator::ConvertToXMLOutputPathSingle(const ch
 void cmLocalVisualStudio7Generator::ConfigureFinalPass()
 {
   cmLocalGenerator::ConfigureFinalPass();
-  cmTargets &tgts = m_Makefile->GetTargets();
+  cmTargets &tgts = this->Makefile->GetTargets();
 
   cmGlobalVisualStudio7Generator* gg =
-    static_cast<cmGlobalVisualStudio7Generator *>(m_GlobalGenerator);
+    static_cast<cmGlobalVisualStudio7Generator *>(this->GlobalGenerator);
   for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
     {
     if (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0)
diff --git a/Source/cmLocalVisualStudio7Generator.h b/Source/cmLocalVisualStudio7Generator.h
index 13ff3df..cc6cd4f 100644
--- a/Source/cmLocalVisualStudio7Generator.h
+++ b/Source/cmLocalVisualStudio7Generator.h
@@ -58,10 +58,10 @@ public:
    */
   std::vector<std::string> GetCreatedProjectNames() 
     {
-    return m_CreatedProjectNames;
+    return this->CreatedProjectNames;
     }
-  void SetVersion71() {m_Version = 71;}
-  void SetVersion8() {m_Version = 8;}
+  void SetVersion71() {this->Version = 71;}
+  void SetVersion8() {this->Version = 8;}
   virtual void ConfigureFinalPass();
 private:
   void FillFlagMapFromCommandFlags(std::map<cmStdString, cmStdString>& flagMap,
@@ -114,11 +114,11 @@ private:
                   const char *libName, std::vector<std::string> *configs);
   virtual std::string GetTargetDirectory(cmTarget&);
 
-  std::vector<std::string> m_CreatedProjectNames;
-  std::string m_LibraryOutputPath;
-  std::string m_ExecutableOutputPath;
-  std::string m_ModuleDefinitionFile;
-  int m_Version;
+  std::vector<std::string> CreatedProjectNames;
+  std::string LibraryOutputPath;
+  std::string ExecutableOutputPath;
+  std::string ModuleDefinitionFile;
+  int Version;
 };
 
 #endif
diff --git a/Source/cmMacroCommand.cxx b/Source/cmMacroCommand.cxx
index eed8e4b..62b1fe6 100644
--- a/Source/cmMacroCommand.cxx
+++ b/Source/cmMacroCommand.cxx
@@ -34,8 +34,8 @@ public:
   {
     cmMacroHelperCommand *newC = new cmMacroHelperCommand;
     // we must copy when we clone
-    newC->m_Args = this->m_Args;
-    newC->m_Functions = this->m_Functions;
+    newC->Args = this->Args;
+    newC->Functions = this->Functions;
     return newC;
   }
 
@@ -55,8 +55,8 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual const char* GetName() { return this->m_Args[0].c_str(); }
-
+  virtual const char* GetName() { return this->Args[0].c_str(); }
+  
   /**
    * Succinct documentation.
    */
@@ -77,8 +77,8 @@ public:
 
   cmTypeMacro(cmMacroHelperCommand, cmCommand);
 
-  std::vector<std::string> m_Args;
-  std::vector<cmListFileFunction> m_Functions;
+  std::vector<std::string> Args;
+  std::vector<cmListFileFunction> Functions;
 };
 
 
@@ -87,7 +87,7 @@ bool cmMacroHelperCommand::InvokeInitialPass
 {
   // Expand the argument list to the macro.
   std::vector<std::string> expandedArgs;
-  m_Makefile->ExpandArguments(args, expandedArgs);
+  this->Makefile->ExpandArguments(args, expandedArgs);
 
   std::string tmps;
   cmListFileArgument arg;
@@ -95,11 +95,11 @@ bool cmMacroHelperCommand::InvokeInitialPass
 
   // make sure the number of arguments passed is at least the number
   // required by the signature
-  if (expandedArgs.size() < m_Args.size() - 1)
+  if (expandedArgs.size() < this->Args.size() - 1)
     {
     std::string errorMsg =
       "Macro invoked with incorrect arguments for macro named: ";
-    errorMsg += m_Args[0];
+    errorMsg += this->Args[0];
     this->SetError(errorMsg.c_str());
     return false;
     }
@@ -118,16 +118,16 @@ bool cmMacroHelperCommand::InvokeInitialPass
   // Invoke all the functions that were collected in the block.
   cmListFileFunction newLFF;
   // for each function
-  for(unsigned int c = 0; c < m_Functions.size(); ++c)
+  for(unsigned int c = 0; c < this->Functions.size(); ++c)
     {
     // Replace the formal arguments and then invoke the command.
-    newLFF.m_Arguments.clear();
-    newLFF.m_Arguments.reserve(m_Functions[c].m_Arguments.size());
-    newLFF.m_Name = m_Functions[c].m_Name;
-    newLFF.m_FilePath = m_Functions[c].m_FilePath;
-    newLFF.m_Line = m_Functions[c].m_Line;
+    newLFF.Arguments.clear();
+    newLFF.Arguments.reserve(this->Functions[c].Arguments.size());
+    newLFF.Name = this->Functions[c].Name;
+    newLFF.FilePath = this->Functions[c].FilePath;
+    newLFF.Line = this->Functions[c].Line;
     const char* def =
-      m_Makefile->GetDefinition("CMAKE_MACRO_REPORT_DEFINITION_LOCATION");
+      this->Makefile->GetDefinition("CMAKE_MACRO_REPORT_DEFINITION_LOCATION"); 
     bool macroReportLocation = false;
     if(def && !cmSystemTools::IsOff(def))
       {
@@ -135,17 +135,17 @@ bool cmMacroHelperCommand::InvokeInitialPass
       }
 
     // for each argument of the current function
-    for (std::vector<cmListFileArgument>::const_iterator k =
-           m_Functions[c].m_Arguments.begin();
-         k != m_Functions[c].m_Arguments.end(); ++k)
+    for (std::vector<cmListFileArgument>::const_iterator k = 
+           this->Functions[c].Arguments.begin();
+         k != this->Functions[c].Arguments.end(); ++k)
       {
       tmps = k->Value;
       // replace formal arguments
-      for (unsigned int j = 1; j < m_Args.size(); ++j)
+      for (unsigned int j = 1; j < this->Args.size(); ++j)
         {
         variable = "${";
-        variable += m_Args[j];
-        variable += "}";
+        variable += this->Args[j];
+        variable += "}"; 
         cmSystemTools::ReplaceString(tmps, variable.c_str(),
                                      expandedArgs[j-1].c_str());
         }
@@ -161,7 +161,7 @@ bool cmMacroHelperCommand::InvokeInitialPass
           std::vector<std::string>::size_type cnt = 0;
           for ( eit = expandedArgs.begin(); eit != expandedArgs.end(); ++eit )
             {
-            if ( cnt >= m_Args.size()-1 )
+            if ( cnt >= this->Args.size()-1 )
               {
               if ( argnDef.size() > 0 )
                 {
@@ -231,15 +231,15 @@ bool cmMacroHelperCommand::InvokeInitialPass
           arg.Line = 0;
           }
         }
-      newLFF.m_Arguments.push_back(arg);
+      newLFF.Arguments.push_back(arg);
       }
-    if(!m_Makefile->ExecuteCommand(newLFF))
+    if(!this->Makefile->ExecuteCommand(newLFF))
       {
       cmOStringStream error;
       error << "Error in cmake code at\n"
             << args[0].FilePath << ":" << args[0].Line << ":\n"
             << "A command failed during the invocation of macro \""
-            << this->m_Args[0].c_str() << "\".";
+            << this->Args[0].c_str() << "\".";
       cmSystemTools::Error(error.str().c_str());
       return false;
       }
@@ -252,29 +252,28 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
 {
   // record commands until we hit the ENDMACRO
   // at the ENDMACRO call we shift gears and start looking for invocations
-  if(cmSystemTools::LowerCase(lff.m_Name) == "endmacro")
+  if(cmSystemTools::LowerCase(lff.Name) == "endmacro")
     {
     std::vector<std::string> expandedArguments;
-    mf.ExpandArguments(lff.m_Arguments, expandedArguments);
-    if(!expandedArguments.empty() && (expandedArguments[0] == m_Args[0]))
+    mf.ExpandArguments(lff.Arguments, expandedArguments);
+    if(!expandedArguments.empty() && (expandedArguments[0] == this->Args[0]))
       {
-      std::string name = m_Args[0];
+      std::string name = this->Args[0];
       std::vector<std::string>::size_type cc;
       name += "(";
-      for ( cc = 0; cc < m_Args.size(); cc ++ )
+      for ( cc = 0; cc < this->Args.size(); cc ++ )
         {
-        name += " " + m_Args[cc];
+        name += " " + this->Args[cc];
         }
       name += " )";
-      mf.AddMacro(m_Args[0].c_str(), name.c_str());
-
+      mf.AddMacro(this->Args[0].c_str(), name.c_str());
       // create a new command and add it to cmake
       cmMacroHelperCommand *f = new cmMacroHelperCommand();
-      f->m_Args = this->m_Args;
-      f->m_Functions = this->m_Functions;
-      std::string newName = "_" + this->m_Args[0];
-      mf.GetCMakeInstance()->RenameCommand(
-        this->m_Args[0].c_str(), newName.c_str());
+      f->Args = this->Args;
+      f->Functions = this->Functions;
+      std::string newName = "_" + this->Args[0];
+      mf.GetCMakeInstance()->RenameCommand(this->Args[0].c_str(), 
+                                           newName.c_str());
       mf.AddCommand(f);
 
       // remove the function blocker now that the macro is defined
@@ -285,7 +284,7 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
 
   // if it wasn't an endmacro and we are not executing then we must be
   // recording
-  m_Functions.push_back(lff);
+  this->Functions.push_back(lff);
   return true;
 }
 
@@ -293,11 +292,11 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
 bool cmMacroFunctionBlocker::
 ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf)
 {
-  if(cmSystemTools::LowerCase(lff.m_Name) == "endmacro")
+  if(cmSystemTools::LowerCase(lff.Name) == "endmacro")
     {
     std::vector<std::string> expandedArguments;
-    mf.ExpandArguments(lff.m_Arguments, expandedArguments);
-    if(!expandedArguments.empty() && (expandedArguments[0] == m_Args[0]))
+    mf.ExpandArguments(lff.Arguments, expandedArguments);
+    if(!expandedArguments.empty() && (expandedArguments[0] == this->Args[0]))
       {
       return true;
       }
@@ -313,7 +312,7 @@ ScopeEnded(cmMakefile &mf)
     "The end of a CMakeLists file was reached with a MACRO statement that "
     "was not closed properly. Within the directory: ",
     mf.GetCurrentDirectory(), " with macro ",
-    m_Args[0].c_str());
+    this->Args[0].c_str());
 }
 
 bool cmMacroCommand::InitialPass(std::vector<std::string> const& args)
@@ -328,11 +327,10 @@ bool cmMacroCommand::InitialPass(std::vector<std::string> const& args)
   cmMacroFunctionBlocker *f = new cmMacroFunctionBlocker();
   for(std::vector<std::string>::const_iterator j = args.begin();
       j != args.end(); ++j)
-    {
-    f->m_Args.push_back(*j);
+    {   
+    f->Args.push_back(*j);
     }
-  m_Makefile->AddFunctionBlocker(f);
-
+  this->Makefile->AddFunctionBlocker(f);
   return true;
 }
 
diff --git a/Source/cmMacroCommand.h b/Source/cmMacroCommand.h
index 44e192b..99e8b91 100644
--- a/Source/cmMacroCommand.h
+++ b/Source/cmMacroCommand.h
@@ -33,9 +33,9 @@ public:
   virtual bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile &mf);
   virtual bool ShouldRemove(const cmListFileFunction&, cmMakefile &mf);
   virtual void ScopeEnded(cmMakefile &mf);
-
-  std::vector<std::string> m_Args;
-  std::vector<cmListFileFunction> m_Functions;
+  
+  std::vector<std::string> Args;
+  std::vector<cmListFileFunction> Functions;
 };
 
 /** \class cmMacroCommand
diff --git a/Source/cmMakeDepend.cxx b/Source/cmMakeDepend.cxx
index 3d32991..31b4d9c 100644
--- a/Source/cmMakeDepend.cxx
+++ b/Source/cmMakeDepend.cxx
@@ -23,22 +23,23 @@ void cmDependInformation::AddDependencies(cmDependInformation* info)
 {
   if(this != info)
     {
-    m_DependencySet.insert(info);
+    this->DependencySet.insert(info);
     }
 }
 
 cmMakeDepend::cmMakeDepend()
 {
-  m_Verbose = false;
-  m_IncludeFileRegularExpression.compile("^.*$");
-  m_ComplainFileRegularExpression.compile("^$");
+  this->Verbose = false;
+  this->IncludeFileRegularExpression.compile("^.*$");
+  this->ComplainFileRegularExpression.compile("^$");
 }
 
 
 cmMakeDepend::~cmMakeDepend()
-{
-  for(DependInformationMap::iterator i = m_DependInformationMap.begin();
-      i != m_DependInformationMap.end(); ++i)
+{ 
+  for(DependInformationMapType::iterator i = 
+        this->DependInformationMap.begin();
+      i != this->DependInformationMap.end(); ++i)
     {
     delete i->second;
     }
@@ -51,22 +52,22 @@ cmMakeDepend::~cmMakeDepend()
 
 void cmMakeDepend::SetMakefile(cmMakefile* makefile)
 {
-  m_Makefile = makefile;
+  this->Makefile = makefile;
 
   // Now extract the include file regular expression from the makefile.
-  m_IncludeFileRegularExpression.compile(
-    m_Makefile->m_IncludeFileRegularExpression.c_str());
-  m_ComplainFileRegularExpression.compile(
-    m_Makefile->m_ComplainFileRegularExpression.c_str());
-
+  this->IncludeFileRegularExpression.compile(
+    this->Makefile->IncludeFileRegularExpression.c_str());
+  this->ComplainFileRegularExpression.compile(
+    this->Makefile->ComplainFileRegularExpression.c_str());
+  
   // Now extract any include paths from the makefile flags
   const std::vector<std::string>& includes =
-    m_Makefile->GetIncludeDirectories();
+    this->Makefile->GetIncludeDirectories();
   for(std::vector<std::string>::const_iterator j = includes.begin();
       j != includes.end(); ++j)
     {
     std::string path = *j;
-    m_Makefile->ExpandVariablesInString(path);
+    this->Makefile->ExpandVariablesInString(path);
     this->AddSearchPath(path.c_str());
     }
 }
@@ -82,16 +83,16 @@ const cmDependInformation* cmMakeDepend::FindDependencies(const char* file)
 void cmMakeDepend::GenerateDependInformation(cmDependInformation* info)
 {
   // If dependencies are already done, stop now.
-  if(info->m_DependDone)
+  if(info->DependDone)
     {
     return;
     }
   else
     {
     // Make sure we don't visit the same file more than once.
-    info->m_DependDone = true;
+    info->DependDone = true;
     }
-  const char* path = info->m_FullPath.c_str();
+  const char* path = info->FullPath.c_str();
   if(!path)
     {
     cmSystemTools::Error(
@@ -112,11 +113,11 @@ void cmMakeDepend::GenerateDependInformation(cmDependInformation* info)
 
   // See if the cmSourceFile for it has any files specified as
   // dependency hints.
-  if(info->m_cmSourceFile != 0)
+  if(info->cmSourceFile != 0)
     {
 
     // Get the cmSourceFile corresponding to this.
-    const cmSourceFile& cFile = *(info->m_cmSourceFile);
+    const cmSourceFile& cFile = *(info->cmSourceFile);
     // See if there are any hints for finding dependencies for the missing
     // file.
     if(!cFile.GetDepends().empty())
@@ -138,9 +139,8 @@ void cmMakeDepend::GenerateDependInformation(cmDependInformation* info)
   if(!found)
     {
     // Try to find the file amongst the sources
-    cmSourceFile *srcFile =
-      m_Makefile->GetSource(
-        cmSystemTools::GetFilenameWithoutExtension(path).c_str());
+    cmSourceFile *srcFile = this->Makefile->GetSource
+      (cmSystemTools::GetFilenameWithoutExtension(path).c_str());
     if (srcFile)
       {
       if (srcFile->GetFullPath() == path)
@@ -150,9 +150,9 @@ void cmMakeDepend::GenerateDependInformation(cmDependInformation* info)
       else
         {
         //try to guess which include path to use
-        for(std::vector<std::string>::iterator t =
-              m_IncludeDirectories.begin();
-            t != m_IncludeDirectories.end(); ++t)
+        for(std::vector<std::string>::iterator t = 
+              this->IncludeDirectories.begin();
+            t != this->IncludeDirectories.end(); ++t)
           {
           std::string incpath = *t;
           if (incpath.size() && incpath[incpath.size() - 1] != '/')
@@ -163,7 +163,7 @@ void cmMakeDepend::GenerateDependInformation(cmDependInformation* info)
           if (srcFile->GetFullPath() == incpath)
             {
             // set the path to the guessed path
-            info->m_FullPath = incpath;
+            info->FullPath = incpath; 
             found=true;
             }
           }
@@ -174,7 +174,7 @@ void cmMakeDepend::GenerateDependInformation(cmDependInformation* info)
   if(!found)
     {
     // Couldn't find any dependency information.
-    if(m_ComplainFileRegularExpression.find(info->m_IncludeName.c_str()))
+    if(this->ComplainFileRegularExpression.find(info->IncludeName.c_str()))
       {
       cmSystemTools::Error("error cannot find dependencies for ", path);
       }
@@ -182,7 +182,7 @@ void cmMakeDepend::GenerateDependInformation(cmDependInformation* info)
       {
       // Destroy the name of the file so that it won't be output as a
       // dependency.
-      info->m_FullPath = "";
+      info->FullPath = "";
       }
     }
 }
@@ -191,12 +191,12 @@ void cmMakeDepend::GenerateDependInformation(cmDependInformation* info)
 // #include directives
 void cmMakeDepend::DependWalk(cmDependInformation* info)
 {
-  cmsys::RegularExpression includeLine(
-    "^[ \t]*#[ \t]*include[ \t]*[<\"]([^\">]+)[\">]");
-  std::ifstream fin(info->m_FullPath.c_str());
+  cmsys::RegularExpression includeLine
+    ("^[ \t]*#[ \t]*include[ \t]*[<\"]([^\">]+)[\">]");
+  std::ifstream fin(info->FullPath.c_str());
   if(!fin)
     {
-    cmSystemTools::Error("Cannot open ", info->m_FullPath.c_str());
+    cmSystemTools::Error("Cannot open ", info->FullPath.c_str());
     return;
     }
 
@@ -209,14 +209,14 @@ void cmMakeDepend::DependWalk(cmDependInformation* info)
       // extract the file being included
       std::string includeFile = includeLine.match(1);
       // see if the include matches the regular expression
-      if(!m_IncludeFileRegularExpression.find(includeFile))
+      if(!this->IncludeFileRegularExpression.find(includeFile))
         {
-        if(m_Verbose)
+        if(this->Verbose)
           {
           std::string message = "Skipping ";
           message += includeFile;
           message += " for file ";
-          message += info->m_FullPath.c_str();
+          message += info->FullPath.c_str();
           cmSystemTools::Error(message.c_str(), 0);
           }
         continue;
@@ -231,8 +231,8 @@ void cmMakeDepend::DependWalk(cmDependInformation* info)
 
 void cmMakeDepend::AddDependency(cmDependInformation* info, const char* file)
 {
-  cmDependInformation* dependInfo =
-    this->GetDependInformation(file, info->m_PathOnly.c_str());
+  cmDependInformation* dependInfo = 
+    this->GetDependInformation(file, info->PathOnly.c_str());
   this->GenerateDependInformation(dependInfo);
   info->AddDependencies(dependInfo);
 }
@@ -244,9 +244,9 @@ cmDependInformation* cmMakeDepend::GetDependInformation(const char* file,
   std::string fullPath = this->FullPath(file, extraPath);
 
   // Try to find the file's instance of cmDependInformation.
-  DependInformationMap::const_iterator result =
-    m_DependInformationMap.find(fullPath);
-  if(result != m_DependInformationMap.end())
+  DependInformationMapType::const_iterator result =
+    this->DependInformationMap.find(fullPath);
+  if(result != this->DependInformationMap.end())
     {
     // Found an instance, return it.
     return result->second;
@@ -255,10 +255,10 @@ cmDependInformation* cmMakeDepend::GetDependInformation(const char* file,
     {
     // Didn't find an instance.  Create a new one and save it.
     cmDependInformation* info = new cmDependInformation;
-    info->m_FullPath = fullPath;
-    info->m_PathOnly = cmSystemTools::GetFilenamePath(fullPath.c_str());
-    info->m_IncludeName = file;
-    m_DependInformationMap[fullPath] = info;
+    info->FullPath = fullPath;
+    info->PathOnly = cmSystemTools::GetFilenamePath(fullPath.c_str());
+    info->IncludeName = file;
+    this->DependInformationMap[fullPath] = info;
     return info;
     }
 }
@@ -267,8 +267,8 @@ cmDependInformation* cmMakeDepend::GetDependInformation(const char* file,
 void cmMakeDepend::GenerateMakefileDependencies()
 {
   // Now create cmDependInformation objects for files in the directory
-  cmTargets &tgts = m_Makefile->GetTargets();
-  for(cmTargets::iterator l = tgts.begin();
+  cmTargets &tgts = this->Makefile->GetTargets();
+  for(cmTargets::iterator l = tgts.begin(); 
       l != tgts.end(); l++)
     {
     const std::vector<cmSourceFile*> &classes = l->second.GetSourceFiles();
@@ -279,8 +279,8 @@ void cmMakeDepend::GenerateMakefileDependencies()
         {
         cmDependInformation* info =
           this->GetDependInformation((*i)->GetFullPath().c_str(),0);
-        this->AddFileToSearchPath(info->m_FullPath.c_str());
-        info->m_cmSourceFile = *i;
+        this->AddFileToSearchPath(info->FullPath.c_str());
+        info->cmSourceFile = *i;
         this->GenerateDependInformation(info);
         }
       }
@@ -288,23 +288,23 @@ void cmMakeDepend::GenerateMakefileDependencies()
 }
 
 
-// find the full path to fname by searching the m_IncludeDirectories array
+// find the full path to fname by searching the this->IncludeDirectories array
 std::string cmMakeDepend::FullPath(const char* fname, const char *extraPath)
 {
-  DirectoryToFileToPathMap::iterator m;
+  DirectoryToFileToPathMapType::iterator m;
   if(extraPath)
     {
-    m = m_DirectoryToFileToPathMap.find(extraPath);
+    m = this->DirectoryToFileToPathMap.find(extraPath);
     }
   else
     {
-    m = m_DirectoryToFileToPathMap.find("");
+    m = this->DirectoryToFileToPathMap.find("");
     }
-
-  if(m != m_DirectoryToFileToPathMap.end())
+  
+  if(m != this->DirectoryToFileToPathMap.end())
     {
-    FileToPathMap& map = m->second;
-    FileToPathMap::iterator p = map.find(fname);
+    FileToPathMapType& map = m->second;
+    FileToPathMapType::iterator p = map.find(fname);
     if(p != map.end())
       {
       return p->second;
@@ -314,12 +314,12 @@ std::string cmMakeDepend::FullPath(const char* fname, const char *extraPath)
   if(cmSystemTools::FileExists(fname))
     {
     std::string fp = cmSystemTools::CollapseFullPath(fname);
-    m_DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp;
+    this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp;
     return fp;
     }
-
-  for(std::vector<std::string>::iterator i = m_IncludeDirectories.begin();
-      i != m_IncludeDirectories.end(); ++i)
+  
+  for(std::vector<std::string>::iterator i = this->IncludeDirectories.begin();
+      i != this->IncludeDirectories.end(); ++i)
     {
     std::string path = *i;
     if (path.size() && path[path.size() - 1] != '/')
@@ -331,7 +331,7 @@ std::string cmMakeDepend::FullPath(const char* fname, const char *extraPath)
        && !cmSystemTools::FileIsDirectory(path.c_str()))
       {
       std::string fp = cmSystemTools::CollapseFullPath(path.c_str());
-      m_DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp;
+      this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp;
       return fp;
       }
     }
@@ -348,7 +348,7 @@ std::string cmMakeDepend::FullPath(const char* fname, const char *extraPath)
        && !cmSystemTools::FileIsDirectory(path.c_str()))
       {
       std::string fp = cmSystemTools::CollapseFullPath(path.c_str());
-      m_DirectoryToFileToPathMap[extraPath][fname] = fp;
+      this->DirectoryToFileToPathMap[extraPath][fname] = fp;
       return fp;
       }
     }
@@ -360,7 +360,7 @@ std::string cmMakeDepend::FullPath(const char* fname, const char *extraPath)
 // Add a directory to the search path
 void cmMakeDepend::AddSearchPath(const char* path)
 {
-  m_IncludeDirectories.push_back(path);
+  this->IncludeDirectories.push_back(path);
 }
 
 // Add a directory to the search path
@@ -371,11 +371,11 @@ void cmMakeDepend::AddFileToSearchPath(const char* file)
   if(pos != std::string::npos)
     {
     std::string path = filepath.substr(0, pos);
-    if(std::find(m_IncludeDirectories.begin(),
-                 m_IncludeDirectories.end(), path)
-       == m_IncludeDirectories.end())
+    if(std::find(this->IncludeDirectories.begin(),
+                 this->IncludeDirectories.end(), path)
+       == this->IncludeDirectories.end())
       {
-      m_IncludeDirectories.push_back(path);
+      this->IncludeDirectories.push_back(path);
       return;
       }
     }
@@ -384,11 +384,12 @@ void cmMakeDepend::AddFileToSearchPath(const char* file)
 const cmDependInformation*
 cmMakeDepend::GetDependInformationForSourceFile(const cmSourceFile &sf) const
 {
-  for(DependInformationMap::const_iterator i = m_DependInformationMap.begin();
-      i != m_DependInformationMap.end(); ++i)
+  for(DependInformationMapType::const_iterator i = 
+        this->DependInformationMap.begin();
+      i != this->DependInformationMap.end(); ++i)
     {
     const cmDependInformation* info = i->second;
-    if(info->m_cmSourceFile == &sf)
+    if(info->cmSourceFile == &sf)
       {
       return info;
       }
diff --git a/Source/cmMakeDepend.h b/Source/cmMakeDepend.h
index 1ac529f..2bf7adf 100644
--- a/Source/cmMakeDepend.h
+++ b/Source/cmMakeDepend.h
@@ -34,40 +34,40 @@ public:
    * Construct with dependency generation marked not done; instance
    * not placed in cmMakefile's list.
    */
-  cmDependInformation(): m_DependDone(false), m_cmSourceFile(0) {}
+  cmDependInformation(): DependDone(false), cmSourceFile(0) {}
 
   /**
    * The set of files on which this one depends.
    */
-  typedef std::set<cmDependInformation*> DependencySet;
-  DependencySet m_DependencySet;
+  typedef std::set<cmDependInformation*> DependencySetType;
+  DependencySetType DependencySet;
 
   /**
    * This flag indicates whether dependency checking has been
    * performed for this file.
    */
-  bool m_DependDone;
+  bool DependDone;
 
   /**
    * If this object corresponds to a cmSourceFile instance, this points
    * to it.
    */
-  const cmSourceFile *m_cmSourceFile;
+  const cmSourceFile *cmSourceFile;
   
   /**
    * Full path to this file.
    */
-  std::string m_FullPath;
+  std::string FullPath;
   
   /**
    * Full path not including file name.
    */
-  std::string m_PathOnly;
+  std::string PathOnly;
   
   /**
    * Name used to #include this file.
    */
-  std::string m_IncludeName;
+  std::string IncludeName;
   
   /**
    * This method adds the dependencies of another file to this one.
@@ -155,16 +155,17 @@ protected:
    */
   std::string FullPath(const char *filename, const char *extraPath);
 
-  cmMakefile* m_Makefile;
-  bool m_Verbose;
-  cmsys::RegularExpression m_IncludeFileRegularExpression;
-  cmsys::RegularExpression m_ComplainFileRegularExpression;
-  std::vector<std::string> m_IncludeDirectories;
-  typedef std::map<cmStdString, cmStdString> FileToPathMap;
-  typedef std::map<cmStdString, FileToPathMap> DirectoryToFileToPathMap;
-  typedef std::map<cmStdString, cmDependInformation*> DependInformationMap;
-  DependInformationMap m_DependInformationMap;
-  DirectoryToFileToPathMap m_DirectoryToFileToPathMap;
+  cmMakefile* Makefile;
+  bool Verbose;
+  cmsys::RegularExpression IncludeFileRegularExpression;
+  cmsys::RegularExpression ComplainFileRegularExpression;
+  std::vector<std::string> IncludeDirectories;
+  typedef std::map<cmStdString, cmStdString> FileToPathMapType;
+  typedef std::map<cmStdString, FileToPathMapType> 
+  DirectoryToFileToPathMapType;
+  typedef std::map<cmStdString, cmDependInformation*> DependInformationMapType;
+  DependInformationMapType DependInformationMap;
+  DirectoryToFileToPathMapType DirectoryToFileToPathMap;
 };
 
 #endif
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 383e1e0..951625e 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -40,36 +40,36 @@
 cmMakefile::cmMakefile()
 {
   // Setup the default include file regular expression (match everything).
-  m_IncludeFileRegularExpression = "^.*$";
+  this->IncludeFileRegularExpression = "^.*$";
   // Setup the default include complaint regular expression (match nothing).
-  m_ComplainFileRegularExpression = "^$";
+  this->ComplainFileRegularExpression = "^$";
   // Source and header file extensions that we can handle
 
   // Set up a list of source and header extensions
   // these are used to find files when the extension 
   // is not given
   // The "c" extension MUST precede the "C" extension.
-  m_SourceFileExtensions.push_back( "c" );
-  m_SourceFileExtensions.push_back( "C" );
+  this->SourceFileExtensions.push_back( "c" );
+  this->SourceFileExtensions.push_back( "C" );
   
-  m_SourceFileExtensions.push_back( "c++" );
-  m_SourceFileExtensions.push_back( "cc" );
-  m_SourceFileExtensions.push_back( "cpp" );
-  m_SourceFileExtensions.push_back( "cxx" );
-  m_SourceFileExtensions.push_back( "m" );
-  m_SourceFileExtensions.push_back( "M" ); 
-  m_SourceFileExtensions.push_back( "mm" );
-
-  m_HeaderFileExtensions.push_back( "h" );
-  m_HeaderFileExtensions.push_back( "h++" );
-  m_HeaderFileExtensions.push_back( "hm" );
-  m_HeaderFileExtensions.push_back( "hpp" );
-  m_HeaderFileExtensions.push_back( "hxx" );
-  m_HeaderFileExtensions.push_back( "in" );
-  m_HeaderFileExtensions.push_back( "txx" );
+  this->SourceFileExtensions.push_back( "c++" );
+  this->SourceFileExtensions.push_back( "cc" );
+  this->SourceFileExtensions.push_back( "cpp" );
+  this->SourceFileExtensions.push_back( "cxx" );
+  this->SourceFileExtensions.push_back( "m" );
+  this->SourceFileExtensions.push_back( "M" ); 
+  this->SourceFileExtensions.push_back( "mm" );
+
+  this->HeaderFileExtensions.push_back( "h" );
+  this->HeaderFileExtensions.push_back( "h++" );
+  this->HeaderFileExtensions.push_back( "hm" );
+  this->HeaderFileExtensions.push_back( "hpp" );
+  this->HeaderFileExtensions.push_back( "hxx" );
+  this->HeaderFileExtensions.push_back( "in" );
+  this->HeaderFileExtensions.push_back( "txx" );
   
-  m_DefineFlags = " ";
-  m_LocalGenerator = 0;
+  this->DefineFlags = " ";
+  this->LocalGenerator = 0;
   this->AddSourceGroup("", "^.*$");
   this->AddSourceGroup("Source Files", 
                        "\\.(C|M|c|c\\+\\+|cc|cpp|cxx|m|mm|rc|def|r|odl|idl|hpj|bat)$");
@@ -77,8 +77,8 @@ cmMakefile::cmMakefile()
   this->AddSourceGroup("CMake Rules", "\\.rule$");
   this->AddSourceGroup("Resources", "\\.plist$");
   this->AddDefaultDefinitions();
-  m_cmDefineRegex.compile("#cmakedefine[ \t]+([A-Za-z_0-9]*)");
-  m_cmDefine01Regex.compile("#cmakedefine01[ \t]+([A-Za-z_0-9]*)");
+  this->cmDefineRegex.compile("#cmakedefine[ \t]+([A-Za-z_0-9]*)");
+  this->cmDefine01Regex.compile("#cmakedefine01[ \t]+([A-Za-z_0-9]*)");
 
   this->PreOrder = false;
 }
@@ -128,27 +128,27 @@ unsigned int cmMakefile::GetCacheMinorVersion()
 cmMakefile::~cmMakefile()
 {
   for(std::vector<cmInstallGenerator*>::iterator
-        i = m_InstallGenerators.begin();
-      i != m_InstallGenerators.end(); ++i)
+        i = this->InstallGenerators.begin();
+      i != this->InstallGenerators.end(); ++i)
     {
     delete *i;
     }
-  for(std::vector<cmSourceFile*>::iterator i = m_SourceFiles.begin();
-      i != m_SourceFiles.end(); ++i)
+  for(std::vector<cmSourceFile*>::iterator i = this->SourceFiles.begin();
+      i != this->SourceFiles.end(); ++i)
     {
     delete *i;
     }
-  for(std::vector<cmTest*>::iterator i = m_Tests.begin();
-      i != m_Tests.end(); ++i)
+  for(std::vector<cmTest*>::iterator i = this->Tests.begin();
+      i != this->Tests.end(); ++i)
     {
     delete *i;
     }
-  for(unsigned int i=0; i < m_UsedCommands.size(); i++)
+  for(unsigned int i=0; i < this->UsedCommands.size(); i++)
     {
-    delete m_UsedCommands[i];
+    delete this->UsedCommands[i];
     }
-  for(DataMap::const_iterator d = m_DataMap.begin();
-      d != m_DataMap.end(); ++d)
+  for(DataMapType::const_iterator d = this->DataMap.begin();
+      d != this->DataMap.end(); ++d)
     {
     if(d->second)
       {
@@ -156,13 +156,13 @@ cmMakefile::~cmMakefile()
       }
     }
   std::list<cmFunctionBlocker *>::iterator pos;
-  for (pos = m_FunctionBlockers.begin(); 
-       pos != m_FunctionBlockers.end(); ++pos)
+  for (pos = this->FunctionBlockers.begin(); 
+       pos != this->FunctionBlockers.end(); ++pos)
     {
     cmFunctionBlocker* b = *pos;
     delete b;
     }
-  m_FunctionBlockers.clear();
+  this->FunctionBlockers.clear();
 }
 
 void cmMakefile::PrintStringVector(const char* s, const std::vector<std::string>& v) const
@@ -194,26 +194,26 @@ void cmMakefile::Print()
   // print the class lists
   std::cout << "classes:\n";
 
-  std::cout << " m_Targets: ";
-  for (cmTargets::iterator l = m_Targets.begin();
-       l != m_Targets.end(); l++)
+  std::cout << " this->Targets: ";
+  for (cmTargets::iterator l = this->Targets.begin();
+       l != this->Targets.end(); l++)
     {
     std::cout << l->first << std::endl;
     }
 
-  std::cout << " m_StartOutputDirectory; " << 
-    m_StartOutputDirectory.c_str() << std::endl;
-  std::cout << " m_HomeOutputDirectory; " << 
-    m_HomeOutputDirectory.c_str() << std::endl;
-  std::cout << " m_cmStartDirectory; " << 
-    m_cmStartDirectory.c_str() << std::endl;
-  std::cout << " m_cmHomeDirectory; " << 
-    m_cmHomeDirectory.c_str() << std::endl;
-  std::cout << " m_ProjectName; " <<  m_ProjectName.c_str() << std::endl;
-  this->PrintStringVector("m_IncludeDirectories;", m_IncludeDirectories);
-  this->PrintStringVector("m_LinkDirectories", m_LinkDirectories);
-  for( std::vector<cmSourceGroup>::const_iterator i = m_SourceGroups.begin();
-       i != m_SourceGroups.end(); ++i)
+  std::cout << " this->StartOutputDirectory; " << 
+    this->StartOutputDirectory.c_str() << std::endl;
+  std::cout << " this->HomeOutputDirectory; " << 
+    this->HomeOutputDirectory.c_str() << std::endl;
+  std::cout << " this->cmStartDirectory; " << 
+    this->cmStartDirectory.c_str() << std::endl;
+  std::cout << " this->cmHomeDirectory; " << 
+    this->cmHomeDirectory.c_str() << std::endl;
+  std::cout << " this->ProjectName; " <<  this->ProjectName.c_str() << std::endl;
+  this->PrintStringVector("this->IncludeDirectories;", this->IncludeDirectories);
+  this->PrintStringVector("this->LinkDirectories", this->LinkDirectories);
+  for( std::vector<cmSourceGroup>::const_iterator i = this->SourceGroups.begin();
+       i != this->SourceGroups.end(); ++i)
     {
     std::cout << "Source Group: " << i->GetName() << std::endl;
     }
@@ -233,7 +233,7 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff)
     // No error.
     return result;
     }
-  std::string name = lff.m_Name;
+  std::string name = lff.Name;
   // execute the command
   cmCommand *rm = 
     this->GetCMakeInstance()->GetCommand(name.c_str());
@@ -251,7 +251,7 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff)
       {
       cmOStringStream error;
       error << "Error in cmake code at\n"
-            << lff.m_FilePath << ":" << lff.m_Line << ":\n"
+            << lff.FilePath << ":" << lff.Line << ":\n"
             << rm->GetError();
       cmSystemTools::Error(error.str().c_str());
       return false;
@@ -263,11 +263,11 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff)
        (!this->GetCMakeInstance()->GetScriptMode() || 
         usedCommand->IsScriptable()))
       {
-      if(!usedCommand->InvokeInitialPass(lff.m_Arguments))
+      if(!usedCommand->InvokeInitialPass(lff.Arguments))
         {
         cmOStringStream error;
         error << "Error in cmake code at\n"
-              << lff.m_FilePath << ":" << lff.m_Line << ":\n"
+              << lff.FilePath << ":" << lff.Line << ":\n"
               << usedCommand->GetError();
         cmSystemTools::Error(error.str().c_str());
         result = false;
@@ -280,14 +280,14 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff)
         {
         // use the command
         keepCommand = true;
-        m_UsedCommands.push_back(usedCommand);
+        this->UsedCommands.push_back(usedCommand);
         }
       }
     else if ( this->GetCMakeInstance()->GetScriptMode() && !usedCommand->IsScriptable() )
       {
       cmOStringStream error;
       error << "Error in cmake code at\n"
-            << lff.m_FilePath << ":" << lff.m_Line << ":\n"
+            << lff.FilePath << ":" << lff.Line << ":\n"
             << "Command " << usedCommand->GetName() << " not scriptable" << std::endl;
       cmSystemTools::Error(error.str().c_str());
       result = false;
@@ -306,8 +306,8 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff)
       {
       cmOStringStream error;
       error << "Error in cmake code at\n"
-            << lff.m_FilePath << ":" << lff.m_Line << ":\n"
-            << "Unknown CMake command \"" << lff.m_Name.c_str() << "\".";
+            << lff.FilePath << ":" << lff.Line << ":\n"
+            << "Unknown CMake command \"" << lff.Name.c_str() << "\".";
       cmSystemTools::Error(error.str().c_str());
       result = false;
       }
@@ -337,13 +337,13 @@ bool cmMakefile::ReadListFile(const char* filename_in, const char *external_in)
     {
     external_abs =
       cmSystemTools::CollapseFullPath(external_in,
-                                      m_cmStartDirectory.c_str());
+                                      this->cmStartDirectory.c_str());
     external = external_abs.c_str();
     if (filename_in)
       {
       filename_abs =
         cmSystemTools::CollapseFullPath(filename_in,
-                                        m_cmStartDirectory.c_str());
+                                        this->cmStartDirectory.c_str());
       filename = filename_abs.c_str();
       }
     }
@@ -351,14 +351,14 @@ bool cmMakefile::ReadListFile(const char* filename_in, const char *external_in)
   // keep track of the current file being read
   if (filename)
     {
-    if(m_cmCurrentListFile != filename)
+    if(this->cmCurrentListFile != filename)
       {
-      m_cmCurrentListFile = filename;
+      this->cmCurrentListFile = filename;
       }
     // loop over current function blockers and record them
     std::list<cmFunctionBlocker *>::iterator pos;
-    for (pos = m_FunctionBlockers.begin(); 
-         pos != m_FunctionBlockers.end(); ++pos)
+    for (pos = this->FunctionBlockers.begin(); 
+         pos != this->FunctionBlockers.end(); ++pos)
       {
       originalBlockers.insert(*pos);
       }
@@ -377,7 +377,7 @@ bool cmMakefile::ReadListFile(const char* filename_in, const char *external_in)
   // one, then cmake will provide one via the 
   // cmListFileCache class.
   bool requireProjectCommand = false;
-  if(!external && m_cmStartDirectory == m_cmHomeDirectory)
+  if(!external && this->cmStartDirectory == this->cmHomeDirectory)
     {
     if(cmSystemTools::LowerCase(
       cmSystemTools::GetFilenameName(filename)) == "cmakelists.txt")
@@ -393,11 +393,11 @@ bool cmMakefile::ReadListFile(const char* filename_in, const char *external_in)
     return false;
     }
   // add this list file to the list of dependencies
-  m_ListFiles.push_back( filenametoread);
-  const size_t numberFunctions = cacheFile.m_Functions.size();
+  this->ListFiles.push_back( filenametoread);
+  const size_t numberFunctions = cacheFile.Functions.size();
   for(size_t i =0; i < numberFunctions; ++i)
     {
-    this->ExecuteCommand(cacheFile.m_Functions[i]);
+    this->ExecuteCommand(cacheFile.Functions[i]);
     if ( cmSystemTools::GetFatalErrorOccured() )
       {
       this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentFile.c_str());
@@ -410,8 +410,8 @@ bool cmMakefile::ReadListFile(const char* filename_in, const char *external_in)
     {
     // loop over all function blockers to see if any block this command
     std::list<cmFunctionBlocker *>::iterator pos;
-    for (pos = m_FunctionBlockers.begin(); 
-         pos != m_FunctionBlockers.end(); ++pos)
+    for (pos = this->FunctionBlockers.begin(); 
+         pos != this->FunctionBlockers.end(); ++pos)
       {
       // if this blocker was not in the original then send a 
       // scope ended message
@@ -435,7 +435,7 @@ void cmMakefile::AddCommand(cmCommand* wg)
 // Set the make file 
 void cmMakefile::SetLocalGenerator(cmLocalGenerator* lg)
 {
-  m_LocalGenerator = lg;
+  this->LocalGenerator = lg;
 }
 
 void cmMakefile::FinalPass()
@@ -445,8 +445,8 @@ void cmMakefile::FinalPass()
 
   // give all the commands a chance to do something
   // after the file has been parsed before generation
-  for(std::vector<cmCommand*>::iterator i = m_UsedCommands.begin();
-      i != m_UsedCommands.end(); ++i)
+  for(std::vector<cmCommand*>::iterator i = this->UsedCommands.begin();
+      i != this->UsedCommands.end(); ++i)
     {
     (*i)->FinalPass();
     }
@@ -463,8 +463,8 @@ void cmMakefile::ConfigureFinalPass()
     {
     cmSystemTools::Error("You have requested backwards compatibility with CMake version 1.2 or earlier. This version of CMake only supports backwards compatibility with CMake 1.4 or later. For compatibility with 1.2 or earlier please use CMake 2.0");
     }
-  for (cmTargets::iterator l = m_Targets.begin();
-       l != m_Targets.end(); l++)
+  for (cmTargets::iterator l = this->Targets.begin();
+       l != this->Targets.end(); l++)
     {
     l->second.GenerateSourceFilesFromSourceLists(*this);
     l->second.AnalyzeLibDependencies(*this);
@@ -481,8 +481,8 @@ cmMakefile::AddCustomCommandToTarget(const char* target,
                                      const char* workingDir)
 {
   // Find the target to which to add the custom command.
-  cmTargets::iterator ti = m_Targets.find(target);
-  if(ti != m_Targets.end())
+  cmTargets::iterator ti = this->Targets.find(target);
+  if(ti != this->Targets.end())
     {
     // Add the command to the appropriate build step for the target.
     const char* no_output = 0;
@@ -656,9 +656,9 @@ cmMakefile::AddCustomCommandOldStyle(const char* target,
     sname += ".rule";
     if(!this->GetSource(sname.c_str()))
       {
-      if (m_Targets.find(target) != m_Targets.end())
+      if (this->Targets.find(target) != this->Targets.end())
         {
-        m_Targets[target].GetSourceLists().push_back(source);
+        this->Targets[target].GetSourceLists().push_back(source);
         }
       else
         {
@@ -725,24 +725,24 @@ void cmMakefile::AddUtilityCommand(const char* utilityName, bool all,
   target.GetPostBuildCommands().push_back(cc);
 
   // Add the target to the set of targets.
-  m_Targets.insert(cmTargets::value_type(utilityName, target));
+  this->Targets.insert(cmTargets::value_type(utilityName, target));
 }
 
 void cmMakefile::AddDefineFlag(const char* flag)
 {
-  m_DefineFlags += " ";
-  m_DefineFlags += flag;
+  this->DefineFlags += " ";
+  this->DefineFlags += flag;
 }
 
 
 void cmMakefile::RemoveDefineFlag(const char* flag)
 {
-  cmSystemTools::ReplaceString(m_DefineFlags, flag, " ");
+  cmSystemTools::ReplaceString(this->DefineFlags, flag, " ");
 }
 
 void cmMakefile::AddLinkLibrary(const char* lib, cmTarget::LinkLibraryType llt)
 {
-  m_LinkLibraries.push_back(
+  this->LinkLibraries.push_back(
     std::pair<std::string, cmTarget::LinkLibraryType>(lib,llt));
 }
 
@@ -750,8 +750,8 @@ void cmMakefile::AddLinkLibraryForTarget(const char *target,
                                          const char* lib, 
                                          cmTarget::LinkLibraryType llt)
 { 
-  cmTargets::iterator i = m_Targets.find(target);
-  if ( i != m_Targets.end())
+  cmTargets::iterator i = this->Targets.find(target);
+  if ( i != this->Targets.end())
     {
     i->second.AddLinkLibrary( *this, target, lib, llt );
     }
@@ -768,8 +768,8 @@ void cmMakefile::AddLinkLibraryForTarget(const char *target,
 void cmMakefile::AddLinkDirectoryForTarget(const char *target,
                                            const char* d)
 {
-  cmTargets::iterator i = m_Targets.find(target);
-  if ( i != m_Targets.end())
+  cmTargets::iterator i = this->Targets.find(target);
+  if ( i != this->Targets.end())
     {
     i->second.AddLinkDirectory( d );
     }
@@ -797,47 +797,47 @@ void cmMakefile::AddLinkDirectory(const char* dir)
     {
     std::string newdir = dir;
     newdir = newdir.substr(0, newdir.size()-1);
-    if(std::find(m_LinkDirectories.begin(),
-                 m_LinkDirectories.end(), newdir.c_str()) == m_LinkDirectories.end())
+    if(std::find(this->LinkDirectories.begin(),
+                 this->LinkDirectories.end(), newdir.c_str()) == this->LinkDirectories.end())
       {
-      m_LinkDirectories.push_back(newdir);
+      this->LinkDirectories.push_back(newdir);
       }
     }
   else
     {
-    if(std::find(m_LinkDirectories.begin(),
-                 m_LinkDirectories.end(), dir) == m_LinkDirectories.end())
+    if(std::find(this->LinkDirectories.begin(),
+                 this->LinkDirectories.end(), dir) == this->LinkDirectories.end())
       {
-      m_LinkDirectories.push_back(dir);
+      this->LinkDirectories.push_back(dir);
       }
     }
 }
 
 void cmMakefile::InitializeFromParent()
 {
-  cmMakefile *parent = m_LocalGenerator->GetParent()->GetMakefile();
+  cmMakefile *parent = this->LocalGenerator->GetParent()->GetMakefile();
   
   // copy the definitions
-  this->m_Definitions = parent->m_Definitions;
+  this->Definitions = parent->Definitions;
 
   // copy include paths
-  this->m_IncludeDirectories = parent->m_IncludeDirectories;
+  this->IncludeDirectories = parent->IncludeDirectories;
   
   // define flags
-  this->m_DefineFlags = parent->m_DefineFlags;
+  this->DefineFlags = parent->DefineFlags;
   
   // link libraries
-  this->m_LinkLibraries = parent->m_LinkLibraries;
+  this->LinkLibraries = parent->LinkLibraries;
   
   // link directories
-  this->m_LinkDirectories = parent->m_LinkDirectories;
+  this->LinkDirectories = parent->LinkDirectories;
   
   // the initial project name
-  this->m_ProjectName = parent->m_ProjectName;
+  this->ProjectName = parent->ProjectName;
 
   // Copy include regular expressions.
-  this->m_IncludeFileRegularExpression = parent->m_IncludeFileRegularExpression;
-  this->m_ComplainFileRegularExpression = parent->m_ComplainFileRegularExpression;
+  this->IncludeFileRegularExpression = parent->IncludeFileRegularExpression;
+  this->ComplainFileRegularExpression = parent->ComplainFileRegularExpression;
 }
 
 void cmMakefile::ConfigureSubDirectory(cmLocalGenerator *lg2)
@@ -880,7 +880,7 @@ void cmMakefile::AddSubDirectory(const char* srcPath, const char *binPath,
                                  bool topLevel, bool preorder, 
                                  bool immediate)
 {
-  std::vector<cmLocalGenerator *>& children = m_LocalGenerator->GetChildren();
+  std::vector<cmLocalGenerator *>& children = this->LocalGenerator->GetChildren();
   // has this directory already been added? If so error
   unsigned int i;
   for (i = 0; i < children.size(); ++i)
@@ -894,9 +894,9 @@ void cmMakefile::AddSubDirectory(const char* srcPath, const char *binPath,
   
   // create a new local generator and set its parent
   cmLocalGenerator *lg2 = 
-    m_LocalGenerator->GetGlobalGenerator()->CreateLocalGenerator();
-  lg2->SetParent(m_LocalGenerator);
-  m_LocalGenerator->GetGlobalGenerator()->AddLocalGenerator(lg2);
+    this->LocalGenerator->GetGlobalGenerator()->CreateLocalGenerator();
+  lg2->SetParent(this->LocalGenerator);
+  this->LocalGenerator->GetGlobalGenerator()->AddLocalGenerator(lg2);
   
   // set the subdirs start dirs
   lg2->GetMakefile()->SetStartDirectory(srcPath);
@@ -917,18 +917,18 @@ void cmMakefile::AddIncludeDirectory(const char* inc, bool before)
   // getting much bigger than 20.  We cannot use a set because of
   // order dependency of the include path.
   std::vector<std::string>::iterator i = 
-    std::find(m_IncludeDirectories.begin(),
-              m_IncludeDirectories.end(), inc);
-  if(i == m_IncludeDirectories.end())
+    std::find(this->IncludeDirectories.begin(),
+              this->IncludeDirectories.end(), inc);
+  if(i == this->IncludeDirectories.end())
     {
     if (before)
       {
       // WARNING: this *is* expensive (linear time) since it's a vector
-      m_IncludeDirectories.insert(m_IncludeDirectories.begin(), inc);
+      this->IncludeDirectories.insert(this->IncludeDirectories.begin(), inc);
       }
     else
       {
-      m_IncludeDirectories.push_back(inc);
+      this->IncludeDirectories.push_back(inc);
       }
     }
   else
@@ -936,9 +936,9 @@ void cmMakefile::AddIncludeDirectory(const char* inc, bool before)
     if(before)
       {
       // if this before and already in the path then remove it
-      m_IncludeDirectories.erase(i);
+      this->IncludeDirectories.erase(i);
       // WARNING: this *is* expensive (linear time) since it's a vector
-      m_IncludeDirectories.insert(m_IncludeDirectories.begin(), inc);
+      this->IncludeDirectories.insert(this->IncludeDirectories.begin(), inc);
       }
     }
 }
@@ -949,14 +949,14 @@ void cmMakefile::AddDefinition(const char* name, const char* value)
     {
     return;
     }
-  m_TemporaryDefinitionKey = name;
-  m_Definitions[m_TemporaryDefinitionKey] = value;
+  this->TemporaryDefinitionKey = name;
+  this->Definitions[this->TemporaryDefinitionKey] = value;
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
   cmVariableWatch* vv = this->GetVariableWatch();
   if ( vv )
     {
-    vv->VariableAccessed(m_TemporaryDefinitionKey, 
+    vv->VariableAccessed(this->TemporaryDefinitionKey, 
                          cmVariableWatch::VARIABLE_MODIFIED_ACCESS);
     }
 #endif
@@ -1004,13 +1004,13 @@ void cmMakefile::AddDefinition(const char* name, bool value)
 {
   if(value)
     {
-    m_Definitions.erase( DefinitionMap::key_type(name));
-    m_Definitions.insert(DefinitionMap::value_type(name, "ON"));
+    this->Definitions.erase( DefinitionMap::key_type(name));
+    this->Definitions.insert(DefinitionMap::value_type(name, "ON"));
     }
   else
     {
-    m_Definitions.erase( DefinitionMap::key_type(name));
-    m_Definitions.insert(DefinitionMap::value_type(name, "OFF"));
+    this->Definitions.erase( DefinitionMap::key_type(name));
+    this->Definitions.insert(DefinitionMap::value_type(name, "OFF"));
     }
 #ifdef CMAKE_BUILD_WITH_CMAKE
   cmVariableWatch* vv = this->GetVariableWatch();
@@ -1038,7 +1038,7 @@ void cmMakefile::AddCacheDefinition(const char* name, bool value, const char* do
 
 void cmMakefile::RemoveDefinition(const char* name)
 {
-  m_Definitions.erase(DefinitionMap::key_type(name));
+  this->Definitions.erase(DefinitionMap::key_type(name));
 #ifdef CMAKE_BUILD_WITH_CMAKE
   cmVariableWatch* vv = this->GetVariableWatch();
   if ( vv )
@@ -1050,7 +1050,7 @@ void cmMakefile::RemoveDefinition(const char* name)
 
 void cmMakefile::SetProjectName(const char* p)
 {
-  m_ProjectName = p;
+  this->ProjectName = p;
 }
 
 
@@ -1067,12 +1067,12 @@ void cmMakefile::AddGlobalLinkInformation(const char* name, cmTarget& target)
     default:;
     }
   std::vector<std::string>::iterator j;
-  for(j = m_LinkDirectories.begin();
-      j != m_LinkDirectories.end(); ++j)
+  for(j = this->LinkDirectories.begin();
+      j != this->LinkDirectories.end(); ++j)
     {
     target.AddLinkDirectory(j->c_str());
     }
-  target.MergeLinkLibraries( *this, name, m_LinkLibraries );
+  target.MergeLinkLibraries( *this, name, this->LinkLibraries );
 }
 
 
@@ -1103,7 +1103,7 @@ void cmMakefile::AddLibrary(const char* lname, int shared,
   target.GetSourceLists() = srcs;
   target.SetMakefile(this);
   this->AddGlobalLinkInformation(lname, target);
-  m_Targets.insert(cmTargets::value_type(lname,target));
+  this->Targets.insert(cmTargets::value_type(lname,target));
 }
 
 cmTarget* cmMakefile::AddExecutable(const char *exeName, 
@@ -1116,7 +1116,7 @@ cmTarget* cmMakefile::AddExecutable(const char *exeName,
   target.SetMakefile(this);
   this->AddGlobalLinkInformation(exeName, target);
   cmTargets::iterator it = 
-    m_Targets.insert(cmTargets::value_type(exeName,target)).first;
+    this->Targets.insert(cmTargets::value_type(exeName,target)).first;
   return &it->second;
 }
 
@@ -1128,8 +1128,8 @@ cmSourceFile *cmMakefile::GetSourceFileWithOutput(const char *cname)
   // look through all the source files that have custom commands
   // and see if the custom command has the passed source file as an output
   // keep in mind the possible .rule extension that may be tacked on
-  for(std::vector<cmSourceFile*>::const_iterator i = m_SourceFiles.begin(); 
-      i != m_SourceFiles.end(); ++i)
+  for(std::vector<cmSourceFile*>::const_iterator i = this->SourceFiles.begin(); 
+      i != this->SourceFiles.end(); ++i)
     {
     // does this source file have a custom command?
     if ((*i)->GetCustomCommand())
@@ -1155,8 +1155,8 @@ cmSourceFile *cmMakefile::GetSourceFileWithOutput(const char *cname)
 cmSourceGroup* cmMakefile::GetSourceGroup(const char* name)
 {
   // First see if the group exists.  If so, replace its regular expression.
-  for(std::vector<cmSourceGroup>::iterator sg = m_SourceGroups.begin();
-      sg != m_SourceGroups.end(); ++sg)
+  for(std::vector<cmSourceGroup>::iterator sg = this->SourceGroups.begin();
+      sg != this->SourceGroups.end(); ++sg)
     {
     std::string sgName = sg->GetName();
     if(sgName == name)
@@ -1179,9 +1179,9 @@ cmSourceGroup* cmMakefile::GetSourceGroup(const char* name)
 void cmMakefile::AddSourceGroup(const char* name, const char* regex, const char *parent)
 {
   // First see if the group exists.  If so, replace its regular expression.
-  for(unsigned int i=0;i<m_SourceGroups.size();++i)
+  for(unsigned int i=0;i<this->SourceGroups.size();++i)
     {
-    cmSourceGroup *sg = &m_SourceGroups[i];
+    cmSourceGroup *sg = &this->SourceGroups[i];
                                 
     std::string sgName = sg->GetName();
     if(!parent)
@@ -1245,12 +1245,12 @@ void cmMakefile::AddSourceGroup(const char* name, const char* regex, const char
     }
                 
   // The group doesn't exist.  Add it.
-  m_SourceGroups.push_back(cmSourceGroup(name, regex));
+  this->SourceGroups.push_back(cmSourceGroup(name, regex));
 }
 
 void cmMakefile::AddExtraDirectory(const char* dir)
 {
-  m_AuxSourceDirectories.push_back(dir);
+  this->AuxSourceDirectories.push_back(dir);
 }
 
 
@@ -1260,18 +1260,19 @@ void cmMakefile::AddExtraDirectory(const char* dir)
 void cmMakefile::ExpandVariables()
 {
   // Now expand variables in the include and link strings
-  for(std::vector<std::string>::iterator d = m_IncludeDirectories.begin();
-      d != m_IncludeDirectories.end(); ++d)
+  for(std::vector<std::string>::iterator d = this->IncludeDirectories.begin();
+      d != this->IncludeDirectories.end(); ++d)
     {
     this->ExpandVariablesInString(*d, true, true);
     }
-  for(std::vector<std::string>::iterator d = m_LinkDirectories.begin();
-      d != m_LinkDirectories.end(); ++d)
+  for(std::vector<std::string>::iterator d = this->LinkDirectories.begin();
+      d != this->LinkDirectories.end(); ++d)
     {
     this->ExpandVariablesInString(*d, true, true);
     }
-  for(cmTarget::LinkLibraries::iterator l = m_LinkLibraries.begin();
-      l != m_LinkLibraries.end(); ++l)
+  for(cmTarget::LinkLibraryVectorType::iterator l = 
+        this->LinkLibraries.begin();
+      l != this->LinkLibraries.end(); ++l)
     {
     this->ExpandVariablesInString(l->first, true, true);
     }
@@ -1320,8 +1321,8 @@ const char* cmMakefile::GetRequiredDefinition(const char* name) const
 const char* cmMakefile::GetDefinition(const char* name) const
 {
   const char* def = 0;
-  DefinitionMap::const_iterator pos = m_Definitions.find(name);
-  if(pos != m_Definitions.end())
+  DefinitionMap::const_iterator pos = this->Definitions.find(name);
+  if(pos != this->Definitions.end())
     {
     def = (*pos).second.c_str();
     }
@@ -1341,8 +1342,8 @@ const char* cmMakefile::GetDefinition(const char* name) const
       {
       // are unknown access allowed
       DefinitionMap::const_iterator pos2 = 
-        m_Definitions.find("CMAKE_ALLOW_UNKNOWN_VARIABLE_READ_ACCESS");
-      if (pos2 != m_Definitions.end() && 
+        this->Definitions.find("CMAKE_ALLOW_UNKNOWN_VARIABLE_READ_ACCESS");
+      if (pos2 != this->Definitions.end() && 
           cmSystemTools::IsOn((*pos2).second.c_str())) 
         {
         vv->VariableAccessed(name, 
@@ -1375,7 +1376,7 @@ std::vector<std::string> cmMakefile::GetDefinitions(int cacheonly /* = 0 */) con
   if ( !cacheonly )
     {
     DefinitionMap::const_iterator it;
-    for ( it = m_Definitions.begin(); it != m_Definitions.end(); it ++ )
+    for ( it = this->Definitions.begin(); it != this->Definitions.end(); it ++ )
       {
       definitions[it->first] = 1;
       }
@@ -1716,7 +1717,7 @@ cmMakefile::FindSourceGroup(const char* source,
 bool cmMakefile::IsFunctionBlocked(const cmListFileFunction& lff)
 {
   // if there are no blockers get out of here
-  if (m_FunctionBlockers.begin() == m_FunctionBlockers.end())
+  if (this->FunctionBlockers.begin() == this->FunctionBlockers.end())
     {
     return false;
     }
@@ -1724,8 +1725,8 @@ bool cmMakefile::IsFunctionBlocked(const cmListFileFunction& lff)
   // loop over all function blockers to see if any block this command
   // evaluate in reverse, this is critical for balanced IF statements etc
   std::list<cmFunctionBlocker *>::reverse_iterator pos;
-  for (pos = m_FunctionBlockers.rbegin(); 
-       pos != m_FunctionBlockers.rend(); ++pos)
+  for (pos = this->FunctionBlockers.rbegin(); 
+       pos != this->FunctionBlockers.rend(); ++pos)
     {
     if((*pos)->IsFunctionBlocked(lff, *this))
       {
@@ -1766,13 +1767,13 @@ void cmMakefile::RemoveFunctionBlocker(const cmListFileFunction& lff)
 {
   // loop over all function blockers to see if any block this command
   std::list<cmFunctionBlocker *>::reverse_iterator pos;
-  for (pos = m_FunctionBlockers.rbegin(); 
-       pos != m_FunctionBlockers.rend(); ++pos)
+  for (pos = this->FunctionBlockers.rbegin(); 
+       pos != this->FunctionBlockers.rend(); ++pos)
     {
     if ((*pos)->ShouldRemove(lff, *this))
       {
       cmFunctionBlocker* b = *pos;
-      m_FunctionBlockers.remove(b);
+      this->FunctionBlockers.remove(b);
       delete b;
       break;
       }
@@ -1783,8 +1784,8 @@ void cmMakefile::RemoveFunctionBlocker(const cmListFileFunction& lff)
 
 void cmMakefile::SetHomeDirectory(const char* dir) 
 {
-  m_cmHomeDirectory = dir;
-  cmSystemTools::ConvertToUnixSlashes(m_cmHomeDirectory);
+  this->cmHomeDirectory = dir;
+  cmSystemTools::ConvertToUnixSlashes(this->cmHomeDirectory);
   this->AddDefinition("CMAKE_SOURCE_DIR", this->GetHomeDirectory());
   if ( !this->GetDefinition("CMAKE_CURRENT_SOURCE_DIR") )
     {
@@ -1794,8 +1795,8 @@ void cmMakefile::SetHomeDirectory(const char* dir)
 
 void cmMakefile::SetHomeOutputDirectory(const char* lib)
 {
-  m_HomeOutputDirectory = lib;
-  cmSystemTools::ConvertToUnixSlashes(m_HomeOutputDirectory);
+  this->HomeOutputDirectory = lib;
+  cmSystemTools::ConvertToUnixSlashes(this->HomeOutputDirectory);
   this->AddDefinition("CMAKE_BINARY_DIR", this->GetHomeOutputDirectory());
   if ( !this->GetDefinition("CMAKE_CURRENT_BINARY_DIR") )
     {
@@ -1810,12 +1811,12 @@ void cmMakefile::SetHomeOutputDirectory(const char* lib)
 void cmMakefile::RegisterData(cmData* data)
 {
   std::string name = data->GetName();
-  DataMap::const_iterator d = m_DataMap.find(name);
-  if((d != m_DataMap.end()) && (d->second != 0) && (d->second != data))
+  DataMapType::const_iterator d = this->DataMap.find(name);
+  if((d != this->DataMap.end()) && (d->second != 0) && (d->second != data))
     {
     delete d->second;
     }
-  m_DataMap[name] = data;
+  this->DataMap[name] = data;
 }
 
 
@@ -1825,12 +1826,12 @@ void cmMakefile::RegisterData(cmData* data)
  */
 void cmMakefile::RegisterData(const char* name, cmData* data)
 {
-  DataMap::const_iterator d = m_DataMap.find(name);
-  if((d != m_DataMap.end()) && (d->second != 0) && (d->second != data))
+  DataMapType::const_iterator d = this->DataMap.find(name);
+  if((d != this->DataMap.end()) && (d->second != 0) && (d->second != data))
     {
     delete d->second;
     }
-  m_DataMap[name] = data;
+  this->DataMap[name] = data;
 }
 
 
@@ -1840,8 +1841,8 @@ void cmMakefile::RegisterData(const char* name, cmData* data)
  */
 cmData* cmMakefile::LookupData(const char* name) const
 {
-  DataMap::const_iterator d = m_DataMap.find(name);
-  if(d != m_DataMap.end())
+  DataMapType::const_iterator d = this->DataMap.find(name);
+  if(d != this->DataMap.end())
     {
     return d->second;
     }
@@ -1872,8 +1873,8 @@ cmSourceFile* cmMakefile::GetSource(const char* sourceName) const
     ext = ext.substr(1);
     }
 
-  for(std::vector<cmSourceFile*>::const_iterator i = m_SourceFiles.begin();
-      i != m_SourceFiles.end(); ++i)
+  for(std::vector<cmSourceFile*>::const_iterator i = this->SourceFiles.begin();
+      i != this->SourceFiles.end(); ++i)
     {
     if ((*i)->GetSourceNameWithoutLastExtension() == sname &&
         cmSystemTools::GetFilenamePath((*i)->GetFullPath()) == path &&
@@ -1890,8 +1891,8 @@ cmSourceFile* cmMakefile::GetSource(const char* sourceName) const
     }
     
   path = this->GetCurrentOutputDirectory();
-  for(std::vector<cmSourceFile*>::const_iterator i = m_SourceFiles.begin();
-      i != m_SourceFiles.end(); ++i)
+  for(std::vector<cmSourceFile*>::const_iterator i = this->SourceFiles.begin();
+      i != this->SourceFiles.end(); ++i)
     {
     if ((*i)->GetSourceName() == sname &&
         cmSystemTools::GetFilenamePath((*i)->GetFullPath()) == path &&
@@ -1985,8 +1986,8 @@ cmSourceFile* cmMakefile::GetOrCreateSource(const char* sourceName,
       {
       ext = ext.substr(1);
       } 
-    bool headerFile = !(std::find( m_HeaderFileExtensions.begin(), m_HeaderFileExtensions.end(), ext ) ==
-                        m_HeaderFileExtensions.end());
+    bool headerFile = !(std::find( this->HeaderFileExtensions.begin(), this->HeaderFileExtensions.end(), ext ) ==
+                        this->HeaderFileExtensions.end());
     file.SetName(name_no_ext.c_str(), path.c_str(), ext.c_str(), headerFile);
     }
   else
@@ -2037,7 +2038,7 @@ cmSourceFile* cmMakefile::AddSource(cmSourceFile const&sf)
     return ret;
     }
   ret = new cmSourceFile(sf);
-  m_SourceFiles.push_back(ret);
+  this->SourceFiles.push_back(ret);
   return ret;
 }
 
@@ -2045,8 +2046,8 @@ cmSourceFile* cmMakefile::AddSource(cmSourceFile const&sf)
 void cmMakefile::EnableLanguage(std::vector<std::string> const &  lang)
 {
   this->AddDefinition("CMAKE_CFG_INTDIR",
-    m_LocalGenerator->GetGlobalGenerator()->GetCMakeCFGInitDirectory());
-  m_LocalGenerator->GetGlobalGenerator()->EnableLanguage(lang, this);
+    this->LocalGenerator->GetGlobalGenerator()->GetCMakeCFGInitDirectory());
+  this->LocalGenerator->GetGlobalGenerator()->EnableLanguage(lang, this);
 }
 
 void cmMakefile::ExpandSourceListArguments(
@@ -2085,7 +2086,7 @@ int cmMakefile::TryCompile(const char *srcdir, const char *bindir,
   cmake cm;
   cm.SetIsInTryCompile(true);
   cmGlobalGenerator *gg = 
-    cm.CreateGlobalGenerator(m_LocalGenerator->GetGlobalGenerator()->GetName());
+    cm.CreateGlobalGenerator(this->LocalGenerator->GetGlobalGenerator()->GetName());
   if (!gg)
     {
     cmSystemTools::Error(
@@ -2109,7 +2110,7 @@ int cmMakefile::TryCompile(const char *srcdir, const char *bindir,
     cm.SetCacheArgs(*cmakeArgs);
     }
   // to save time we pass the EnableLanguage info directly
-  gg->EnableLanguagesFromGenerator(m_LocalGenerator->GetGlobalGenerator());
+  gg->EnableLanguagesFromGenerator(this->LocalGenerator->GetGlobalGenerator());
   
   if (cm.Configure() != 0)
     {
@@ -2131,7 +2132,7 @@ int cmMakefile::TryCompile(const char *srcdir, const char *bindir,
 
   // finally call the generator to actually build the resulting project
   int ret = 
-    m_LocalGenerator->GetGlobalGenerator()->TryCompile(srcdir,bindir,
+    this->LocalGenerator->GetGlobalGenerator()->TryCompile(srcdir,bindir,
                                                        projectName, 
                                                        targetName,
                                                        output,
@@ -2143,9 +2144,9 @@ int cmMakefile::TryCompile(const char *srcdir, const char *bindir,
 
 cmake *cmMakefile::GetCMakeInstance() const
 {
-  if ( m_LocalGenerator && m_LocalGenerator->GetGlobalGenerator() )
+  if ( this->LocalGenerator && this->LocalGenerator->GetGlobalGenerator() )
     {
-    return m_LocalGenerator->GetGlobalGenerator()->GetCMakeInstance();
+    return this->LocalGenerator->GetGlobalGenerator()->GetCMakeInstance();
     }
   return 0;
 }
@@ -2168,7 +2169,7 @@ void cmMakefile::AddMacro(const char* name, const char* signature)
     {
     return;
     }
-  m_MacrosMap[name] = signature;
+  this->MacrosMap[name] = signature;
 }
 
 void cmMakefile::GetListOfMacros(std::string& macros)
@@ -2176,7 +2177,7 @@ void cmMakefile::GetListOfMacros(std::string& macros)
   StringStringMap::iterator it;
   macros = "";
   int cc = 0;
-  for ( it = m_MacrosMap.begin(); it != m_MacrosMap.end(); ++it )
+  for ( it = this->MacrosMap.begin(); it != this->MacrosMap.end(); ++it )
     {
     if ( cc > 0 )
       {
@@ -2257,9 +2258,9 @@ void cmMakefile::ConfigureString(const std::string& input,
       }
 
     // Replace #cmakedefine instances.
-    if(m_cmDefineRegex.find(line))
+    if(this->cmDefineRegex.find(line))
       {
-      const char* def = this->GetDefinition(m_cmDefineRegex.match(1).c_str());
+      const char* def = this->GetDefinition(this->cmDefineRegex.match(1).c_str());
       if(!cmSystemTools::IsOff(def))
         {
         cmSystemTools::ReplaceString(line, "#cmakedefine", "#define");
@@ -2273,9 +2274,9 @@ void cmMakefile::ConfigureString(const std::string& input,
         output += " */";
         }
       }
-    else if(m_cmDefine01Regex.find(line))
+    else if(this->cmDefine01Regex.find(line))
       {
-      const char* def = this->GetDefinition(m_cmDefine01Regex.match(1).c_str());
+      const char* def = this->GetDefinition(this->cmDefine01Regex.match(1).c_str());
       cmSystemTools::ReplaceString(line, "#cmakedefine01", "#define");
       output += line;
       if(!cmSystemTools::IsOff(def))
@@ -2393,8 +2394,8 @@ bool cmMakefile::HasWrittenFile(const char* file)
 bool cmMakefile::CheckInfiniteLoops()
 {
   std::vector<std::string>::iterator it;
-  for ( it = m_ListFiles.begin();
-        it != m_ListFiles.end();
+  for ( it = this->ListFiles.begin();
+        it != this->ListFiles.end();
         ++ it )
     {
     if ( this->HasWrittenFile(it->c_str()) )
@@ -2418,14 +2419,14 @@ void cmMakefile::SetProperty(const char* prop, const char* value)
     {
     value = "NOTFOUND";
     }
-  m_Properties[prop] = value;
+  this->Properties[prop] = value;
 }
 
 const char *cmMakefile::GetProperty(const char* prop) const
 {
   std::map<cmStdString,cmStdString>::const_iterator i = 
-    m_Properties.find(prop);
-  if (i != m_Properties.end())
+    this->Properties.find(prop);
+  if (i != this->Properties.end())
     {
     return i->second.c_str();
     }
@@ -2435,8 +2436,8 @@ const char *cmMakefile::GetProperty(const char* prop) const
 bool cmMakefile::GetPropertyAsBool(const char* prop) const
 {
   std::map<cmStdString,cmStdString>::const_iterator i = 
-    m_Properties.find(prop);
-  if (i != m_Properties.end())
+    this->Properties.find(prop);
+  if (i != this->Properties.end())
     {
     return cmSystemTools::IsOn(i->second.c_str());
     }
@@ -2470,7 +2471,7 @@ cmTest* cmMakefile::CreateTest(const char* testName)
     }
   test = new cmTest;
   test->SetName(testName);
-  m_Tests.push_back(test);
+  this->Tests.push_back(test);
   return test;
 }
 
@@ -2481,7 +2482,7 @@ cmTest* cmMakefile::GetTest(const char* testName) const
     return 0;
     }
   std::vector<cmTest*>::const_iterator it;
-  for ( it = m_Tests.begin(); it != m_Tests.end(); ++ it )
+  for ( it = this->Tests.begin(); it != this->Tests.end(); ++ it )
     {
     if ( strcmp((*it)->GetName(), testName) == 0 )
       {
@@ -2493,11 +2494,11 @@ cmTest* cmMakefile::GetTest(const char* testName) const
 
 const std::vector<cmTest*> *cmMakefile::GetTests() const
 {
-  return &m_Tests;
+  return &this->Tests;
 }
 
 std::vector<cmTest*> *cmMakefile::GetTests()
 {
-  return &m_Tests;
+  return &this->Tests;
 }
 
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index 8dd9163..7b6dbfa 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -81,9 +81,9 @@ public:
    * Add a function blocker to this makefile
    */
   void AddFunctionBlocker(cmFunctionBlocker *fb)
-    { m_FunctionBlockers.push_back(fb);}
+    { this->FunctionBlockers.push_back(fb);}
   void RemoveFunctionBlocker(cmFunctionBlocker *fb)
-    { m_FunctionBlockers.remove(fb);}
+    { this->FunctionBlockers.remove(fb);}
   void RemoveFunctionBlocker(const cmListFileFunction& lff);
 
   /**
@@ -116,7 +116,7 @@ public:
   
   ///! Get the current makefile generator.
   cmLocalGenerator* GetLocalGenerator() 
-    { return m_LocalGenerator;}
+    { return this->LocalGenerator;}
 
   /**
    * Perform FinalPass, Library dependency analysis etc before output of the
@@ -203,15 +203,15 @@ public:
    */
   std::vector<std::string>& GetLinkDirectories()
     {
-      return m_LinkDirectories;
+      return this->LinkDirectories;
     }
   const std::vector<std::string>& GetLinkDirectories() const
     {
-      return m_LinkDirectories;
+      return this->LinkDirectories;
     }
   void SetLinkDirectories(const std::vector<std::string>& vec)
     {
-      m_LinkDirectories = vec;
+      this->LinkDirectories = vec;
     }
 
   /**
@@ -266,7 +266,7 @@ public:
    */
   const char* GetProjectName()
     {
-      return m_ProjectName.c_str();
+      return this->ProjectName.c_str();
     }
   
   /**
@@ -293,9 +293,9 @@ public:
   void MakeStartDirectoriesCurrent()
     {
       this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", 
-                          m_cmStartDirectory.c_str());
+                          this->cmStartDirectory.c_str());
       this->AddDefinition("CMAKE_CURRENT_BINARY_DIR", 
-                          m_StartOutputDirectory.c_str());
+                          this->StartOutputDirectory.c_str());
     }
   
   //@{
@@ -309,12 +309,12 @@ public:
   void SetHomeDirectory(const char* dir);
   const char* GetHomeDirectory() const
     {
-      return m_cmHomeDirectory.c_str();
+      return this->cmHomeDirectory.c_str();
     }
   void SetHomeOutputDirectory(const char* lib);
   const char* GetHomeOutputDirectory() const
     {
-      return m_HomeOutputDirectory.c_str();
+      return this->HomeOutputDirectory.c_str();
     }
   //@}
   
@@ -328,36 +328,36 @@ public:
    */
   void SetStartDirectory(const char* dir) 
     {
-      m_cmStartDirectory = dir;
-      cmSystemTools::ConvertToUnixSlashes(m_cmStartDirectory);
+      this->cmStartDirectory = dir;
+      cmSystemTools::ConvertToUnixSlashes(this->cmStartDirectory);
       this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", 
-                          m_cmStartDirectory.c_str());
+                          this->cmStartDirectory.c_str());
     }
   const char* GetStartDirectory() const
     {
-      return m_cmStartDirectory.c_str();
+      return this->cmStartDirectory.c_str();
     }
   void SetStartOutputDirectory(const char* lib)
     {
-      m_StartOutputDirectory = lib;
-      cmSystemTools::ConvertToUnixSlashes(m_StartOutputDirectory);
-      cmSystemTools::MakeDirectory(m_StartOutputDirectory.c_str());
+      this->StartOutputDirectory = lib;
+      cmSystemTools::ConvertToUnixSlashes(this->StartOutputDirectory);
+      cmSystemTools::MakeDirectory(this->StartOutputDirectory.c_str());
       this->AddDefinition("CMAKE_CURRENT_BINARY_DIR", 
-                          m_StartOutputDirectory.c_str());
+                          this->StartOutputDirectory.c_str());
     }
   const char* GetStartOutputDirectory() const
     {
-      return m_StartOutputDirectory.c_str();
+      return this->StartOutputDirectory.c_str();
     }
   //@}
 
   const char* GetCurrentDirectory() const 
     {
-      return m_cmStartDirectory.c_str();
+      return this->cmStartDirectory.c_str();
     }
   const char* GetCurrentOutputDirectory() const
     {
-      return m_StartOutputDirectory.c_str();
+      return this->StartOutputDirectory.c_str();
     }
 
   /* Get the current CMakeLists.txt file that is being processed.  This
@@ -365,7 +365,7 @@ public:
    * transparently */
   const char* GetCurrentListFile() const
     {
-      return m_cmCurrentListFile.c_str();
+      return this->cmCurrentListFile.c_str();
     }
 
   //@}
@@ -376,11 +376,11 @@ public:
    */
   void SetIncludeRegularExpression(const char* regex)
     {
-      m_IncludeFileRegularExpression = regex;
+      this->IncludeFileRegularExpression = regex;
     }
   const char* GetIncludeRegularExpression()
     { 
-      return m_IncludeFileRegularExpression.c_str();
+      return this->IncludeFileRegularExpression.c_str();
     }
 
   /** 
@@ -389,17 +389,17 @@ public:
    */
   void SetComplainRegularExpression(const char* regex)
     {
-      m_ComplainFileRegularExpression = regex;
+      this->ComplainFileRegularExpression = regex;
     }
   const char* GetComplainRegularExpression()
     {
-      return m_ComplainFileRegularExpression.c_str();
+      return this->ComplainFileRegularExpression.c_str();
     }
 
   /**
    * Get the list of targets
    */
-  cmTargets &GetTargets() { return m_Targets; }
+  cmTargets &GetTargets() { return this->Targets; }
 
   cmTarget* FindTarget(const char* name);
 
@@ -408,15 +408,15 @@ public:
    */
   std::vector<std::string>& GetIncludeDirectories()
     { 
-      return m_IncludeDirectories;
+      return this->IncludeDirectories;
     }
   const std::vector<std::string>& GetIncludeDirectories() const
     { 
-      return m_IncludeDirectories;
+      return this->IncludeDirectories;
     }
   void SetIncludeDirectories(const std::vector<std::string>& vec)
     {
-      m_IncludeDirectories = vec;
+      this->IncludeDirectories = vec;
     }
 
   /** Expand out any arguements in the vector that have ; separated
@@ -449,7 +449,7 @@ public:
    * Obtain a list of auxiliary source directories.
    */
   std::vector<std::string>& GetAuxSourceDirectories()
-    {return m_AuxSourceDirectories;}
+    {return this->AuxSourceDirectories;}
 
   //@{
   /**
@@ -457,9 +457,9 @@ public:
    * files
    */
   const std::vector<std::string>& GetSourceExtensions() const
-    {return m_SourceFileExtensions;}
+    {return this->SourceFileExtensions;}
   const std::vector<std::string>& GetHeaderExtensions() const
-    {return m_HeaderFileExtensions;}
+    {return this->HeaderFileExtensions;}
   //@}
 
   /**
@@ -487,19 +487,19 @@ public:
    * Get a list of preprocessor define flags.
    */
   const char* GetDefineFlags()
-    {return m_DefineFlags.c_str();}
+    {return this->DefineFlags.c_str();}
   
   /**
    * Get the vector of used command instances.
    */
   const std::vector<cmCommand*>& GetUsedCommands() const
-    {return m_UsedCommands;}
+    {return this->UsedCommands;}
   
   /**
    * Get the vector source groups.
    */
   const std::vector<cmSourceGroup>& GetSourceGroups() const
-    { return m_SourceGroups; }
+    { return this->SourceGroups; }
 
   /**
    * Get the source group
@@ -510,17 +510,17 @@ public:
    * Get the vector of list files on which this makefile depends
    */
   const std::vector<std::string>& GetListFiles() const
-    { return m_ListFiles; }
+    { return this->ListFiles; }
   
   ///! When the file changes cmake will be re-run from the build system.
   void AddCMakeDependFile(const char* file)
-    { m_ListFiles.push_back(file);}
+    { this->ListFiles.push_back(file);}
   
   /**
    * Expand all defined variables in the string.  
-   * Defined variables come from the m_Definitions map.
+   * Defined variables come from the this->Definitions map.
    * They are expanded with ${var} where var is the
-   * entry in the m_Definitions map.  Also @var@ is
+   * entry in the this->Definitions map.  Also @var@ is
    * expanded to match autoconf style expansions.
    */
   const char *ExpandVariablesInString(std::string& source) const;
@@ -613,8 +613,8 @@ public:
    * Get all the source files this makefile knows about
    */
   const std::vector<cmSourceFile*> &GetSourceFiles() const 
-    {return m_SourceFiles;}
-  std::vector<cmSourceFile*> &GetSourceFiles() {return m_SourceFiles;}
+    {return this->SourceFiles;}
+  std::vector<cmSourceFile*> &GetSourceFiles() {return this->SourceFiles;}
 
   /**
    * Is there a source file that has the provided source file as an output?
@@ -662,80 +662,82 @@ public:
   bool GetPreOrder() { return this->PreOrder; }
 
   void AddInstallGenerator(cmInstallGenerator* g)
-    { m_InstallGenerators.push_back(g); }
+    { this->InstallGenerators.push_back(g); }
   std::vector<cmInstallGenerator*>& GetInstallGenerators()
-    { return m_InstallGenerators; }
+    { return this->InstallGenerators; }
 protected:
   // add link libraries and directories to the target
   void AddGlobalLinkInformation(const char* name, cmTarget& target);
   
-  std::string m_Prefix;
-  std::vector<std::string> m_AuxSourceDirectories; // 
+  std::string Prefix;
+  std::vector<std::string> AuxSourceDirectories; // 
 
-  std::string m_cmStartDirectory; 
-  std::string m_StartOutputDirectory; 
-  std::string m_cmHomeDirectory; 
-  std::string m_HomeOutputDirectory;
-  std::string m_cmCurrentListFile;
+  std::string cmStartDirectory; 
+  std::string StartOutputDirectory; 
+  std::string cmHomeDirectory; 
+  std::string HomeOutputDirectory;
+  std::string cmCurrentListFile;
 
-  std::string m_ProjectName;    // project name
+  std::string ProjectName;    // project name
 
   // libraries, classes, and executables
-  cmTargets m_Targets;
-  std::vector<cmSourceFile*> m_SourceFiles;
+  cmTargets Targets;
+  std::vector<cmSourceFile*> SourceFiles;
 
   // Tests
-  std::vector<cmTest*> m_Tests;
+  std::vector<cmTest*> Tests;
   
   // The include and link-library paths.  These may have order
   // dependency, so they must be vectors (not set).
-  std::vector<std::string> m_IncludeDirectories;
-  std::vector<std::string> m_LinkDirectories;
+  std::vector<std::string> IncludeDirectories;
+  std::vector<std::string> LinkDirectories;
   
-  std::vector<std::string> m_ListFiles; // list of command files loaded
+  std::vector<std::string> ListFiles; // list of command files loaded
   
   
-  cmTarget::LinkLibraries m_LinkLibraries;
-
-  std::vector<cmInstallGenerator*> m_InstallGenerators;
-
-  std::string m_IncludeFileRegularExpression;
-  std::string m_ComplainFileRegularExpression;
-  std::vector<std::string> m_SourceFileExtensions;
-  std::vector<std::string> m_HeaderFileExtensions;
-  std::string m_DefineFlags;
-  std::vector<cmSourceGroup> m_SourceGroups;
-  DefinitionMap m_Definitions;
-  std::vector<cmCommand*> m_UsedCommands;
-  cmLocalGenerator* m_LocalGenerator;
+  cmTarget::LinkLibraryVectorType LinkLibraries;
+
+  std::vector<cmInstallGenerator*> InstallGenerators;
+
+  std::string IncludeFileRegularExpression;
+  std::string ComplainFileRegularExpression;
+  std::vector<std::string> SourceFileExtensions;
+  std::vector<std::string> HeaderFileExtensions;
+  std::string DefineFlags;
+  std::vector<cmSourceGroup> SourceGroups;
+  DefinitionMap Definitions;
+  std::vector<cmCommand*> UsedCommands;
+  cmLocalGenerator* LocalGenerator;
   bool IsFunctionBlocked(const cmListFileFunction& lff);
   
 private:
 
   void ReadSources(std::ifstream& fin, bool t);
   friend class cmMakeDepend;    // make depend needs direct access 
+
                                 // to the m_Sources array 
   void PrintStringVector(const char* s, const 
                          std::vector<std::pair<cmStdString, bool> >& v) const;
   void PrintStringVector(const char* s, 
                          const std::vector<std::string>& v) const;
+
   void AddDefaultDefinitions();
-  std::list<cmFunctionBlocker *> m_FunctionBlockers;
+  std::list<cmFunctionBlocker *> FunctionBlockers;
 
-  typedef std::map<cmStdString, cmData*> DataMap;
-  DataMap m_DataMap;
+  typedef std::map<cmStdString, cmData*> DataMapType;
+  DataMapType DataMap;
 
   typedef std::map<cmStdString, cmStdString> StringStringMap;
-  StringStringMap m_MacrosMap;
+  StringStringMap MacrosMap;
 
-  std::map<cmStdString, bool> m_SubDirectoryOrder;
+  std::map<cmStdString, bool> SubDirectoryOrder;
   // used in AddDefinition for performance improvement
-  DefinitionMap::key_type  m_TemporaryDefinitionKey;
+  DefinitionMap::key_type  TemporaryDefinitionKey;
 
-  cmsys::RegularExpression m_cmDefineRegex;
-  cmsys::RegularExpression m_cmDefine01Regex;
+  cmsys::RegularExpression cmDefineRegex;
+  cmsys::RegularExpression cmDefine01Regex;
 
-  std::map<cmStdString,cmStdString> m_Properties;
+  std::map<cmStdString,cmStdString> Properties;
 
   // should this makefile be processed before or after processing the parent
   bool PreOrder;
diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx
index 1bdf709..afdca4d 100644
--- a/Source/cmMakefileExecutableTargetGenerator.cxx
+++ b/Source/cmMakefileExecutableTargetGenerator.cxx
@@ -96,10 +96,10 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
   std::string targetName;
   std::string targetNameReal;
   this->Target->GetExecutableNames(targetName, targetNameReal,
-                                   this->LocalGenerator->m_ConfigurationName.c_str());
+                                   this->LocalGenerator->ConfigurationName.c_str());
 
   // Construct the full path version of the names.
-  std::string outpath = this->LocalGenerator->m_ExecutableOutputPath;
+  std::string outpath = this->LocalGenerator->ExecutableOutputPath;
   if(outpath.length() == 0)
     {
     outpath = this->Makefile->GetStartOutputDirectory();
@@ -191,7 +191,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
   // Add flags to create an executable.
   this->LocalGenerator->
     AddConfigVariableFlags(linkFlags, "CMAKE_EXE_LINKER_FLAGS",
-                           this->LocalGenerator->m_ConfigurationName.c_str());
+                           this->LocalGenerator->ConfigurationName.c_str());
 
 
   if(this->Target->GetPropertyAsBool("WIN32_EXECUTABLE"))
@@ -208,7 +208,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
   // Add language-specific flags.
   this->LocalGenerator
     ->AddLanguageFlags(flags, linkLanguage,
-                       this->LocalGenerator->m_ConfigurationName.c_str());
+                       this->LocalGenerator->ConfigurationName.c_str());
 
   // Add target-specific linker flags.
   this->LocalGenerator->AppendFlags(linkFlags, this->Target->GetProperty("LINK_FLAGS"));
@@ -220,7 +220,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
   std::string cleanName;
   std::string cleanRealName;
   this->Target->GetExecutableCleanNames(cleanName, cleanRealName,
-                                        this->LocalGenerator->m_ConfigurationName.c_str());
+                                        this->LocalGenerator->ConfigurationName.c_str());
   std::string cleanFullName = outpath + cleanName;
   std::string cleanFullRealName = outpath + cleanRealName;
   exeCleanFiles.push_back(this->Convert(cleanFullName.c_str(),
diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx
index 4ae00db..585d025 100644
--- a/Source/cmMakefileLibraryTargetGenerator.cxx
+++ b/Source/cmMakefileLibraryTargetGenerator.cxx
@@ -110,7 +110,7 @@ void cmMakefileLibraryTargetGenerator::WriteSharedLibraryRules(bool relink)
   std::string extraFlags;
   this->LocalGenerator->AppendFlags(extraFlags, this->Target->GetProperty("LINK_FLAGS"));
   this->LocalGenerator->AddConfigVariableFlags(extraFlags, "CMAKE_SHARED_LINKER_FLAGS",
-                                               this->LocalGenerator->m_ConfigurationName.c_str());
+                                               this->LocalGenerator->ConfigurationName.c_str());
   if(this->Makefile->IsOn("WIN32") && !(this->Makefile->IsOn("CYGWIN") || this->Makefile->IsOn("MINGW")))
     {
     const std::vector<cmSourceFile*>& sources = this->Target->GetSourceFiles();
@@ -144,7 +144,7 @@ void cmMakefileLibraryTargetGenerator::WriteModuleLibraryRules(bool relink)
   std::string extraFlags;
   this->LocalGenerator->AppendFlags(extraFlags, this->Target->GetProperty("LINK_FLAGS"));
   this->LocalGenerator->AddConfigVariableFlags(extraFlags, "CMAKE_MODULE_LINKER_FLAGS",
-                                               this->LocalGenerator->m_ConfigurationName.c_str());
+                                               this->LocalGenerator->ConfigurationName.c_str());
   // TODO: .def files should be supported here also.
   this->WriteLibraryRules(linkRuleVar.c_str(), extraFlags.c_str(), relink);
 }
@@ -207,10 +207,10 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
   std::string targetNameImport;
   this->Target->GetLibraryNames(
     targetName, targetNameSO, targetNameReal, targetNameImport,
-    this->LocalGenerator->m_ConfigurationName.c_str());
+    this->LocalGenerator->ConfigurationName.c_str());
 
   // Construct the full path version of the names.
-  std::string outpath = this->LocalGenerator->m_LibraryOutputPath;
+  std::string outpath = this->LocalGenerator->LibraryOutputPath;
   if(outpath.length() == 0)
     {
     outpath = this->Makefile->GetStartOutputDirectory();
@@ -282,7 +282,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
     cleanSharedSOName,
     cleanSharedRealName,
     cleanImportName,
-    this->LocalGenerator->m_ConfigurationName.c_str());
+    this->LocalGenerator->ConfigurationName.c_str());
   std::string cleanFullStaticName = outpath + cleanStaticName;
   std::string cleanFullSharedName = outpath + cleanSharedName;
   std::string cleanFullSharedSOName = outpath + cleanSharedSOName;
@@ -407,7 +407,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
     {
     // Select whether to generate an install_name directory for the
     // install tree or the build tree.
-    const char* config = this->LocalGenerator->m_ConfigurationName.c_str();
+    const char* config = this->LocalGenerator->ConfigurationName.c_str();
     if(this->Target->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH"))
       {
       install_name_dir =
@@ -442,7 +442,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
   std::string langFlags;
   this->LocalGenerator
     ->AddLanguageFlags(langFlags, linkLanguage,
-                       this->LocalGenerator->m_ConfigurationName.c_str());
+                       this->LocalGenerator->ConfigurationName.c_str());
   // remove any language flags that might not work with the
   // particular os
   if(forbiddenFlagVar)
@@ -452,13 +452,13 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
     }
   vars.LanguageCompileFlags = langFlags.c_str();
   // Expand placeholders in the commands.
-  this->LocalGenerator->m_TargetImplib = targetOutPathImport;
+  this->LocalGenerator->TargetImplib = targetOutPathImport;
   for(std::vector<std::string>::iterator i = commands.begin();
       i != commands.end(); ++i)
     {
     this->LocalGenerator->ExpandRuleVariables(*i, vars);
     }
-  this->LocalGenerator->m_TargetImplib = "";
+  this->LocalGenerator->TargetImplib = "";
 
   // Write the build rule.
   this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0,
diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index 842c6eb..d0b5de3 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -121,7 +121,7 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
   dependFileNameFull += "/depend.make";
   *this->BuildFileStream
     << "# Include any dependencies generated for this target.\n"
-    << this->LocalGenerator->m_IncludeDirective << " "
+    << this->LocalGenerator->IncludeDirective << " "
     << this->Convert(dependFileNameFull.c_str(),
                                      cmLocalGenerator::HOME_OUTPUT,
                                      cmLocalGenerator::MAKEFILE)
@@ -153,7 +153,7 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
   // Include the flags for the target.
   *this->BuildFileStream
     << "# Include the compile flags for this target's objects.\n"
-    << this->LocalGenerator->m_IncludeDirective << " "
+    << this->LocalGenerator->IncludeDirective << " "
     << this->Convert(this->FlagFileNameFull.c_str(), 
                                      cmLocalGenerator::HOME_OUTPUT, 
                                      cmLocalGenerator::MAKEFILE)
@@ -221,7 +221,7 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
     // Add language-specific flags.
     this->LocalGenerator
       ->AddLanguageFlags(flags, lang,
-                         this->LocalGenerator->m_ConfigurationName.c_str());
+                         this->LocalGenerator->ConfigurationName.c_str());
     
     // Add shared-library flags if needed.
     this->LocalGenerator->AddSharedFlags(flags, lang, shared);
@@ -258,9 +258,9 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(cmSourceFile& source)
     this->LocalGenerator->GetObjectFileName(*this->Target, source, &objNoTargetDir);
 
   // Avoid generating duplicate rules.
-  if(m_ObjectFiles.find(obj) == m_ObjectFiles.end())
+  if(this->ObjectFiles.find(obj) == this->ObjectFiles.end())
     {
-    m_ObjectFiles.insert(obj);
+    this->ObjectFiles.insert(obj);
     }
   else
     {
@@ -294,13 +294,13 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(cmSourceFile& source)
   this->WriteObjectBuildFile(obj, lang, source, depends);
   
   // The object file should be checked for dependency integrity.
-  this->LocalGenerator->m_CheckDependFiles[this->Target->GetName()][lang].insert(&source);
+  this->LocalGenerator->CheckDependFiles[this->Target->GetName()][lang].insert(&source);
   // add this to the list of objects for this local generator
   if(cmSystemTools::FileIsFullPath(objNoTargetDir.c_str()))
     {
     objNoTargetDir = cmSystemTools::GetFilenameName(objNoTargetDir);
     }
-  this->LocalGenerator->m_LocalObjectFiles[objNoTargetDir].push_back(this->Target);
+  this->LocalGenerator->LocalObjectFiles[objNoTargetDir].push_back(this->Target);
 }
 
 //----------------------------------------------------------------------------
@@ -352,7 +352,7 @@ cmMakefileTargetGenerator
   
   // Get the output paths for source and object files.
   std::string sourceFile = source.GetFullPath();
-  if(this->LocalGenerator->m_UseRelativePaths)
+  if(this->LocalGenerator->UseRelativePaths)
     {
     sourceFile = this->Convert(sourceFile.c_str(),
                                                cmLocalGenerator::HOME_OUTPUT);
@@ -770,8 +770,9 @@ void cmMakefileTargetGenerator
   emitted.insert(this->Target->GetName());
 
   // Loop over all library dependencies.
-  const cmTarget::LinkLibraries& tlibs = this->Target->GetLinkLibraries();
-  for(cmTarget::LinkLibraries::const_iterator lib = tlibs.begin();
+  const cmTarget::LinkLibraryVectorType& tlibs = 
+    this->Target->GetLinkLibraries();
+  for(cmTarget::LinkLibraryVectorType::const_iterator lib = tlibs.begin();
       lib != tlibs.end(); ++lib)
     {
     // Don't emit the same library twice for this target.
@@ -782,7 +783,7 @@ void cmMakefileTargetGenerator
          this->GlobalGenerator->FindTarget(0, lib->first.c_str()))
         {
         if(const char* location =
-           tgt->GetLocation(this->LocalGenerator->m_ConfigurationName.c_str()))
+           tgt->GetLocation(this->LocalGenerator->ConfigurationName.c_str()))
           {
           depends.push_back(location);
           }
diff --git a/Source/cmMakefileTargetGenerator.h b/Source/cmMakefileTargetGenerator.h
index 9bc2345..85f0fb2 100644
--- a/Source/cmMakefileTargetGenerator.h
+++ b/Source/cmMakefileTargetGenerator.h
@@ -134,7 +134,7 @@ protected:
   std::vector<std::string> ExternalObjects;
 
   // Set of object file names that will be built in this directory.
-  std::set<cmStdString> m_ObjectFiles;
+  std::set<cmStdString> ObjectFiles;
 
 
   //==================================================================
diff --git a/Source/cmMarkAsAdvancedCommand.cxx b/Source/cmMarkAsAdvancedCommand.cxx
index 3195387..2034d4c 100644
--- a/Source/cmMarkAsAdvancedCommand.cxx
+++ b/Source/cmMarkAsAdvancedCommand.cxx
@@ -40,11 +40,11 @@ bool cmMarkAsAdvancedCommand::InitialPass(std::vector<std::string> const& args)
   for(; i < args.size(); ++i)
     {
     std::string variable = args[i];
-    cmCacheManager* manager = m_Makefile->GetCacheManager();
+    cmCacheManager* manager = this->Makefile->GetCacheManager();
     cmCacheManager::CacheIterator it = manager->GetCacheIterator(variable.c_str());
     if ( it.IsAtEnd() )
       {
-      m_Makefile->AddCacheDefinition(variable.c_str(), 0, 0,
+      this->Makefile->AddCacheDefinition(variable.c_str(), 0, 0,
                                      cmCacheManager::UNINITIALIZED);
       overwrite = true;
       }
diff --git a/Source/cmMathCommand.cxx b/Source/cmMathCommand.cxx
index bbb3edc..6c8f7a2 100644
--- a/Source/cmMathCommand.cxx
+++ b/Source/cmMathCommand.cxx
@@ -60,6 +60,6 @@ bool cmMathCommand::HandleExprCommand(std::vector<std::string> const& args)
   char buffer[1024];
   sprintf(buffer, "%d", helper.GetResult());
 
-  m_Makefile->AddDefinition(outputVariable.c_str(), buffer);
+  this->Makefile->AddDefinition(outputVariable.c_str(), buffer);
   return true;
 }
diff --git a/Source/cmMessageCommand.cxx b/Source/cmMessageCommand.cxx
index e275d75..2ba6fd7 100644
--- a/Source/cmMessageCommand.cxx
+++ b/Source/cmMessageCommand.cxx
@@ -65,7 +65,7 @@ bool cmMessageCommand::InitialPass(std::vector<std::string> const& args)
     {
       if (status)
         {
-          m_Makefile->DisplayStatus(message.c_str(), -1);
+          this->Makefile->DisplayStatus(message.c_str(), -1);
         }
       else
         {
diff --git a/Source/cmOptionCommand.cxx b/Source/cmOptionCommand.cxx
index 37e3be0..8682c91 100644
--- a/Source/cmOptionCommand.cxx
+++ b/Source/cmOptionCommand.cxx
@@ -27,7 +27,7 @@ bool cmOptionCommand::InitialPass(std::vector<std::string> const& args)
   // for VTK 4.0 we have to support the option command with more than 3 arguments
   // if CMAKE_MINIMUM_REQUIRED_VERSION is not defined, if CMAKE_MINIMUM_REQUIRED_VERSION
   // is defined, then we can have stricter checking.
-  if(m_Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION"))
+  if(this->Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION"))
     {
     if(args.size() > 3)
       {
@@ -50,7 +50,7 @@ bool cmOptionCommand::InitialPass(std::vector<std::string> const& args)
   // Now check and see if the value has been stored in the cache
   // already, if so use that value and don't look for the program
   cmCacheManager::CacheIterator it = 
-    m_Makefile->GetCacheManager()->GetCacheIterator(args[0].c_str());
+    this->Makefile->GetCacheManager()->GetCacheIterator(args[0].c_str());
   if(!it.IsAtEnd())
     {
     if ( it.GetType() != cmCacheManager::UNINITIALIZED )
@@ -67,7 +67,7 @@ bool cmOptionCommand::InitialPass(std::vector<std::string> const& args)
     {
     initialValue = args[2];
     }
-  m_Makefile->AddCacheDefinition(args[0].c_str(),
+  this->Makefile->AddCacheDefinition(args[0].c_str(),
     cmSystemTools::IsOn(initialValue.c_str()),
     args[1].c_str());
 
diff --git a/Source/cmOrderLinkDirectories.cxx b/Source/cmOrderLinkDirectories.cxx
index add18d7..a0feeae 100644
--- a/Source/cmOrderLinkDirectories.cxx
+++ b/Source/cmOrderLinkDirectories.cxx
@@ -7,7 +7,7 @@
 //-------------------------------------------------------------------
 cmOrderLinkDirectories::cmOrderLinkDirectories()
 {
-  m_Debug = false;
+  this->Debug = false;
 }
 
 //-------------------------------------------------------------------
@@ -24,12 +24,12 @@ bool cmOrderLinkDirectories::LibraryInDirectory(const char* dir,
     }
   // next remove the extension (.a, .so ) and look for the library
   // under a different name as the linker can do either
-  if(m_RemoveLibraryExtension.find(libIn))
+  if(this->RemoveLibraryExtension.find(libIn))
     {
-    cmStdString lib = m_RemoveLibraryExtension.match(1);
-    cmStdString ext = m_RemoveLibraryExtension.match(2);
-    for(std::vector<cmStdString>::iterator i = m_LinkExtensions.begin();
-        i != m_LinkExtensions.end(); ++i)
+    cmStdString lib = this->RemoveLibraryExtension.match(1);
+    cmStdString ext = this->RemoveLibraryExtension.match(2);
+    for(std::vector<cmStdString>::iterator i = this->LinkExtensions.begin();
+        i != this->LinkExtensions.end(); ++i)
       {
       if(ext != *i)
         {
@@ -49,18 +49,18 @@ bool cmOrderLinkDirectories::LibraryInDirectory(const char* dir,
 //-------------------------------------------------------------------
 void cmOrderLinkDirectories::FindLibrariesInSeachPaths()
 {
-  for(std::set<cmStdString>::iterator dir = m_LinkPathSet.begin();
-      dir != m_LinkPathSet.end(); ++dir)
+  for(std::set<cmStdString>::iterator dir = this->LinkPathSet.begin();
+      dir != this->LinkPathSet.end(); ++dir)
     {
     for(std::map<cmStdString, Library>::iterator lib
-          = m_FullPathLibraries.begin();
-        lib != m_FullPathLibraries.end(); ++lib)
+          = this->FullPathLibraries.begin();
+        lib != this->FullPathLibraries.end(); ++lib)
       {
       if(lib->second.Path != *dir)
         {
         if(this->LibraryInDirectory(dir->c_str(), lib->second.File.c_str()))
           {
-          m_LibraryToDirectories[lib->second.FullPath].push_back(*dir);
+          this->LibraryToDirectories[lib->second.FullPath].push_back(*dir);
           }
         }
       }
@@ -70,11 +70,11 @@ void cmOrderLinkDirectories::FindLibrariesInSeachPaths()
 //-------------------------------------------------------------------
 void cmOrderLinkDirectories::FindIndividualLibraryOrders()
 {
-  for(std::vector<Library>::iterator lib = m_MultiDirectoryLibraries.begin();
-      lib != m_MultiDirectoryLibraries.end(); ++lib)
+  for(std::vector<Library>::iterator lib = this->MultiDirectoryLibraries.begin();
+      lib != this->MultiDirectoryLibraries.end(); ++lib)
     {
-    std::vector<cmStdString>& dirs = m_LibraryToDirectories[lib->FullPath];
-    m_DirectoryToAfterList[lib->Path] = dirs;
+    std::vector<cmStdString>& dirs = this->LibraryToDirectories[lib->FullPath];
+    this->DirectoryToAfterList[lib->Path] = dirs;
     }
 }
 
@@ -104,11 +104,11 @@ std::string cmOrderLinkDirectories::NoCaseExpression(const char* str)
 //-------------------------------------------------------------------
 void cmOrderLinkDirectories::CreateRegularExpressions()
 {
-  m_SplitFramework.compile("(.*)/(.*)\\.framework$");
+  this->SplitFramework.compile("(.*)/(.*)\\.framework$");
   cmStdString libext = "(";
   bool first = true;
-  for(std::vector<cmStdString>::iterator i = m_LinkExtensions.begin();
-      i != m_LinkExtensions.end(); ++i)
+  for(std::vector<cmStdString>::iterator i = this->LinkExtensions.begin();
+      i != this->LinkExtensions.end(); ++i)
     {
     if(!first)
       {
@@ -125,36 +125,36 @@ void cmOrderLinkDirectories::CreateRegularExpressions()
   libext += ").*";
   cmStdString reg("(.*)");
   reg += libext;
-  m_RemoveLibraryExtension.compile(reg.c_str());
+  this->RemoveLibraryExtension.compile(reg.c_str());
   reg = "";
-  if(m_LinkPrefix.size())
+  if(this->LinkPrefix.size())
     {
     reg = "^";
-    reg += m_LinkPrefix;
+    reg += this->LinkPrefix;
     }
   reg += "([^/]*)";
   reg += libext;
-  m_ExtractBaseLibraryName.compile(reg.c_str());
+  this->ExtractBaseLibraryName.compile(reg.c_str());
   reg = "([^/]*)";
   reg += libext;
-  m_ExtractBaseLibraryNameNoPrefix.compile(reg.c_str());
+  this->ExtractBaseLibraryNameNoPrefix.compile(reg.c_str());
 }
 
 
 //-------------------------------------------------------------------
 void cmOrderLinkDirectories::PrepareLinkTargets()
 {
-  for(std::vector<cmStdString>::iterator i = m_LinkItems.begin();
-      i != m_LinkItems.end(); ++i)
+  for(std::vector<cmStdString>::iterator i = this->LinkItems.begin();
+      i != this->LinkItems.end(); ++i)
     {
     // separate the library name from libfoo.a or foo.a
-    if(m_ExtractBaseLibraryName.find(*i))
+    if(this->ExtractBaseLibraryName.find(*i))
       {
-      *i = m_ExtractBaseLibraryName.match(1);
+      *i = this->ExtractBaseLibraryName.match(1);
       }
-    else if(m_ExtractBaseLibraryNameNoPrefix.find(*i))
+    else if(this->ExtractBaseLibraryNameNoPrefix.find(*i))
       {
-      *i = m_ExtractBaseLibraryNameNoPrefix.match(1);
+      *i = this->ExtractBaseLibraryNameNoPrefix.match(1);
       }
     }
 }
@@ -164,13 +164,13 @@ bool cmOrderLinkDirectories::FindPathNotInDirectoryToAfterList(
   cmStdString& path)
 {
   for(std::map<cmStdString, std::vector<cmStdString> >::iterator i
-        = m_DirectoryToAfterList.begin();
-      i != m_DirectoryToAfterList.end(); ++i)
+        = this->DirectoryToAfterList.begin();
+      i != this->DirectoryToAfterList.end(); ++i)
     {
     const cmStdString& p = i->first;
     bool found = false;
     for(std::map<cmStdString, std::vector<cmStdString> >::iterator j 
-          = m_DirectoryToAfterList.begin(); j != m_DirectoryToAfterList.end() 
+          = this->DirectoryToAfterList.begin(); j != this->DirectoryToAfterList.end() 
           && !found; ++j)
       {
       if(j != i)
@@ -181,7 +181,7 @@ bool cmOrderLinkDirectories::FindPathNotInDirectoryToAfterList(
     if(!found)
       {
       path = p;
-      m_DirectoryToAfterList.erase(i);
+      this->DirectoryToAfterList.erase(i);
       return true;
       }
     }
@@ -199,20 +199,20 @@ void cmOrderLinkDirectories::OrderPaths(std::vector<cmStdString>&
   // One at a time find paths that are not in any other paths after list
   // and put them into the orderedPaths vector in that order
   // FindPathNotInDirectoryToAfterList removes the path from the
-  // m_DirectoryToAfterList once it is found
+  // this->DirectoryToAfterList once it is found
   while(this->FindPathNotInDirectoryToAfterList(path))
     {
     orderedPaths.push_back(path);
     }
-  // at this point if there are still paths in m_DirectoryToAfterList
+  // at this point if there are still paths in this->DirectoryToAfterList
   // then there is a cycle and we are stuck
-  if(m_DirectoryToAfterList.size())
+  if(this->DirectoryToAfterList.size())
     {
     for(std::map<cmStdString, std::vector<cmStdString> >::iterator i
-          = m_DirectoryToAfterList.begin();
-        i != m_DirectoryToAfterList.end(); ++i)
+          = this->DirectoryToAfterList.begin();
+        i != this->DirectoryToAfterList.end(); ++i)
       {
-      m_ImpossibleDirectories.insert(i->first);
+      this->ImpossibleDirectories.insert(i->first);
       // still put it in the path list in the order we find them
       orderedPaths.push_back(i->first);
       }
@@ -228,22 +228,22 @@ void cmOrderLinkDirectories::SetLinkInformation(
   )
 {
   // Save the target name.
-  m_TargetName = targetName;
+  this->TargetName = targetName;
 
   // Merge the link directory search path given into our path set.
   std::vector<cmStdString> empty;
   for(std::vector<std::string>::const_iterator p = linkDirectories.begin();
       p != linkDirectories.end(); ++p)
     {
-    m_DirectoryToAfterList[*p] = empty;
-    m_LinkPathSet.insert(*p);
+    this->DirectoryToAfterList[*p] = empty;
+    this->LinkPathSet.insert(*p);
     }
 
   // Append the link library list into our raw list.
   for(std::vector<std::string>::const_iterator l = linkLibraries.begin();
       l != linkLibraries.end(); ++l)
     {
-    m_RawLinkItems.push_back(*l);
+    this->RawLinkItems.push_back(*l);
     }
 }
 
@@ -259,35 +259,35 @@ bool cmOrderLinkDirectories::DetermineLibraryPathOrder()
   cmStdString file;
   std::vector<cmStdString> empty;
   bool framework = false;
-  for(unsigned int i=0; i < m_RawLinkItems.size(); ++i)
+  for(unsigned int i=0; i < this->RawLinkItems.size(); ++i)
     {
-    if(cmSystemTools::FileIsFullPath(m_RawLinkItems[i].c_str()))
+    if(cmSystemTools::FileIsFullPath(this->RawLinkItems[i].c_str()))
       {
-      if(cmSystemTools::FileIsDirectory(m_RawLinkItems[i].c_str()))
+      if(cmSystemTools::FileIsDirectory(this->RawLinkItems[i].c_str()))
         {
-        if(cmSystemTools::IsPathToFramework(m_RawLinkItems[i].c_str()))
+        if(cmSystemTools::IsPathToFramework(this->RawLinkItems[i].c_str()))
           {
-          m_SplitFramework.find(m_RawLinkItems[i]);
-          cmStdString path = m_SplitFramework.match(1);
+          this->SplitFramework.find(this->RawLinkItems[i]);
+          cmStdString path = this->SplitFramework.match(1);
           // Add the -F path if we have not yet done so
-          if(m_EmittedFrameworkPaths.insert(path).second)
+          if(this->EmittedFrameworkPaths.insert(path).second)
             {
             std::string fpath = "-F";
             fpath += cmSystemTools::ConvertToOutputPath(path.c_str());
-            m_LinkItems.push_back(fpath);
+            this->LinkItems.push_back(fpath);
             }
           // now add the -framework option
           std::string frame = "-framework ";
-          frame += m_SplitFramework.match(2);
-          m_LinkItems.push_back(frame);
+          frame += this->SplitFramework.match(2);
+          this->LinkItems.push_back(frame);
           framework = true;
           }
         else
           {
           std::string message = "Warning: Ignoring path found in link libraries for target: ";
-          message += m_TargetName;
+          message += this->TargetName;
           message += ", path is: ";
-          message += m_RawLinkItems[i];
+          message += this->RawLinkItems[i];
           message += ". Expected a library name or a full path to a library name.";
           cmSystemTools::Message(message.c_str());
           continue;
@@ -295,7 +295,7 @@ bool cmOrderLinkDirectories::DetermineLibraryPathOrder()
         }
       if(!framework)
         {
-        cmSystemTools::SplitProgramPath(m_RawLinkItems[i].c_str(),
+        cmSystemTools::SplitProgramPath(this->RawLinkItems[i].c_str(),
                                         dir, file);
 #ifdef _WIN32
         // Avoid case problems for windows paths.
@@ -308,46 +308,46 @@ bool cmOrderLinkDirectories::DetermineLibraryPathOrder()
           }
         dir = cmSystemTools::GetActualCaseForPath(dir.c_str());
 #endif
-        m_DirectoryToAfterList[dir] = empty;
-        m_LinkPathSet.insert(dir);
-        aLib.FullPath = m_RawLinkItems[i];
+        this->DirectoryToAfterList[dir] = empty;
+        this->LinkPathSet.insert(dir);
+        aLib.FullPath = this->RawLinkItems[i];
         aLib.File = file;
         aLib.Path = dir;
-        m_FullPathLibraries[aLib.FullPath] = aLib;
-        m_LinkItems.push_back(file);
+        this->FullPathLibraries[aLib.FullPath] = aLib;
+        this->LinkItems.push_back(file);
         }
       }
     else
       {
-      m_LinkItems.push_back(m_RawLinkItems[i]);
+      this->LinkItems.push_back(this->RawLinkItems[i]);
       }
     }
   this->FindLibrariesInSeachPaths();
   for(std::map<cmStdString, std::vector<cmStdString> >::iterator lib =
-        m_LibraryToDirectories.begin(); lib!= m_LibraryToDirectories.end(); 
+        this->LibraryToDirectories.begin(); lib!= this->LibraryToDirectories.end(); 
       ++lib)
     {
     if(lib->second.size() > 0)
       {
-      m_MultiDirectoryLibraries.push_back(m_FullPathLibraries[lib->first]);
+      this->MultiDirectoryLibraries.push_back(this->FullPathLibraries[lib->first]);
       }
     else
       {
-      m_SingleDirectoryLibraries.push_back(m_FullPathLibraries[lib->first]);
+      this->SingleDirectoryLibraries.push_back(this->FullPathLibraries[lib->first]);
       }
     }
   this->FindIndividualLibraryOrders();
-  m_SortedSearchPaths.clear();
-  if(m_Debug)
+  this->SortedSearchPaths.clear();
+  if(this->Debug)
     {
-    this->PrintMap("m_LibraryToDirectories", m_LibraryToDirectories);
-    this->PrintMap("m_DirectoryToAfterList", m_DirectoryToAfterList);
+    this->PrintMap("this->LibraryToDirectories", this->LibraryToDirectories);
+    this->PrintMap("this->DirectoryToAfterList", this->DirectoryToAfterList);
     }
-  this->OrderPaths(m_SortedSearchPaths); 
+  this->OrderPaths(this->SortedSearchPaths); 
   // now turn libfoo.a into foo and foo.a into foo
   // This will prepare the link items for -litem 
   this->PrepareLinkTargets();
-  if(m_ImpossibleDirectories.size())
+  if(this->ImpossibleDirectories.size())
     {
     cmSystemTools::Message(this->GetWarnings().c_str());
     return false;
@@ -358,15 +358,15 @@ bool cmOrderLinkDirectories::DetermineLibraryPathOrder()
 std::string cmOrderLinkDirectories::GetWarnings()
 {
   std::string warning = "It is impossible to order the linker search path in such a way that libraries specified as full paths will be picked by the linker.\nDirectories and libraries involved are:\n";
-  for(std::set<cmStdString>::iterator i = m_ImpossibleDirectories.begin();
-      i != m_ImpossibleDirectories.end(); ++i)
+  for(std::set<cmStdString>::iterator i = this->ImpossibleDirectories.begin();
+      i != this->ImpossibleDirectories.end(); ++i)
     {
     warning += "Directory: ";
     warning += *i;
     warning += " contains:\n";
     std::map<cmStdString, std::vector<cmStdString> >::iterator j;
-    for(j = m_LibraryToDirectories.begin(); 
-        j != m_LibraryToDirectories.end(); ++j)
+    for(j = this->LibraryToDirectories.begin(); 
+        j != this->LibraryToDirectories.end(); ++j)
       {
       if(std::find(j->second.begin(), j->second.end(), *i)
          != j->second.end())
@@ -405,8 +405,8 @@ cmOrderLinkDirectories::PrintMap(const char* name,
 void cmOrderLinkDirectories::GetFullPathLibraries(std::vector<cmStdString>& 
                                                   libs)
 {
-  for(std::map<cmStdString, Library>::iterator i = m_FullPathLibraries.begin();
-      i != m_FullPathLibraries.end(); ++i)
+  for(std::map<cmStdString, Library>::iterator i = this->FullPathLibraries.begin();
+      i != this->FullPathLibraries.end(); ++i)
     {
     libs.push_back(i->first);
     }
diff --git a/Source/cmOrderLinkDirectories.h b/Source/cmOrderLinkDirectories.h
index 3a82a19..7d4c5e8 100644
--- a/Source/cmOrderLinkDirectories.h
+++ b/Source/cmOrderLinkDirectories.h
@@ -58,8 +58,8 @@ public:
   void GetLinkerInformation(std::vector<cmStdString>& searchPaths,
                             std::vector<cmStdString>& linkItems)
   {
-    linkItems = m_LinkItems;
-    searchPaths = m_SortedSearchPaths;
+    linkItems = this->LinkItems;
+    searchPaths = this->SortedSearchPaths;
   }
   // should be set from CMAKE_STATIC_LIBRARY_SUFFIX,
   // CMAKE_SHARED_LIBRARY_SUFFIX
@@ -68,7 +68,7 @@ public:
     {
     if(e && *e)
       {
-      m_LinkExtensions.push_back(e);
+      this->LinkExtensions.push_back(e);
       }
     }
   // should be set from CMAKE_STATIC_LIBRARY_PREFIX
@@ -76,7 +76,7 @@ public:
     {
     if(s)
       {
-      m_LinkPrefix = s;
+      this->LinkPrefix = s;
       }
     }
   // Return any warnings if the exist
@@ -94,7 +94,7 @@ public:
   friend struct cmOrderLinkDirectoriesCompare;
   void DebugOn() 
     {
-      m_Debug = true;
+      this->Debug = true;
     }
   
 private:
@@ -113,39 +113,39 @@ private:
   std::string NoCaseExpression(const char* str);
 private:
   // map from library to directories that it is in other than its full path
-  std::map<cmStdString, std::vector<cmStdString> > m_LibraryToDirectories;
+  std::map<cmStdString, std::vector<cmStdString> > LibraryToDirectories;
   // map from directory to vector of directories that must be after it
-  std::map<cmStdString, std::vector<cmStdString> > m_DirectoryToAfterList;
+  std::map<cmStdString, std::vector<cmStdString> > DirectoryToAfterList;
   // map from full path to a Library struct
-  std::map<cmStdString, Library> m_FullPathLibraries;
+  std::map<cmStdString, Library> FullPathLibraries;
   // libraries that are found in multiple directories
-  std::vector<Library> m_MultiDirectoryLibraries;
+  std::vector<Library> MultiDirectoryLibraries;
   // libraries that are only found in one directory
-  std::vector<Library> m_SingleDirectoryLibraries;
+  std::vector<Library> SingleDirectoryLibraries;
   // This is a vector of all the link objects -lm or m
-  std::vector<cmStdString> m_LinkItems;
+  std::vector<cmStdString> LinkItems;
   // Unprocessed link items
-  std::vector<cmStdString> m_RawLinkItems;
+  std::vector<cmStdString> RawLinkItems;
   // This vector holds the sorted -L paths
-  std::vector<cmStdString> m_SortedSearchPaths;
+  std::vector<cmStdString> SortedSearchPaths;
   // This vector holds the -F paths
-  std::set<cmStdString> m_EmittedFrameworkPaths;
+  std::set<cmStdString> EmittedFrameworkPaths;
   // This is the set of -L paths unsorted, but unique
-  std::set<cmStdString> m_LinkPathSet;
+  std::set<cmStdString> LinkPathSet;
   // the names of link extensions
-  std::vector<cmStdString> m_LinkExtensions;
+  std::vector<cmStdString> LinkExtensions;
   // the names of link prefixes
-  cmStdString m_LinkPrefix;
+  cmStdString LinkPrefix;
   // set of directories that can not be put in the correct order
-  std::set<cmStdString> m_ImpossibleDirectories;
+  std::set<cmStdString> ImpossibleDirectories;
   // Name of target
-  cmStdString m_TargetName;
+  cmStdString TargetName;
   // library regular expressions
-  cmsys::RegularExpression m_RemoveLibraryExtension;
-  cmsys::RegularExpression m_ExtractBaseLibraryName;
-  cmsys::RegularExpression m_ExtractBaseLibraryNameNoPrefix;
-  cmsys::RegularExpression m_SplitFramework;
-  bool m_Debug;
+  cmsys::RegularExpression RemoveLibraryExtension;
+  cmsys::RegularExpression ExtractBaseLibraryName;
+  cmsys::RegularExpression ExtractBaseLibraryNameNoPrefix;
+  cmsys::RegularExpression SplitFramework;
+  bool Debug;
 };
 
 #endif
diff --git a/Source/cmOutputRequiredFilesCommand.cxx b/Source/cmOutputRequiredFilesCommand.cxx
index 4121e1b..600e008 100644
--- a/Source/cmOutputRequiredFilesCommand.cxx
+++ b/Source/cmOutputRequiredFilesCommand.cxx
@@ -27,10 +27,10 @@ class cmLBDepend : public cmMakeDepend
 
 void cmLBDepend::DependWalk(cmDependInformation* info)
 {
-  std::ifstream fin(info->m_FullPath.c_str());
+  std::ifstream fin(info->FullPath.c_str());
   if(!fin)
     {
-    cmSystemTools::Error("error can not open ", info->m_FullPath.c_str());
+    cmSystemTools::Error("error can not open ", info->FullPath.c_str());
     return;
     }
   
@@ -66,14 +66,14 @@ void cmLBDepend::DependWalk(cmDependInformation* info)
       // extract the file being included
       std::string includeFile = currentline.substr(qstart+1, qend - qstart-1);
       // see if the include matches the regular expression
-      if(!m_IncludeFileRegularExpression.find(includeFile))
+      if(!this->IncludeFileRegularExpression.find(includeFile))
         {
-        if(m_Verbose)
+        if(this->Verbose)
           {
           std::string message = "Skipping ";
           message += includeFile;
           message += " for file ";
-          message += info->m_FullPath.c_str();
+          message += info->FullPath.c_str();
           cmSystemTools::Error(message.c_str(), 0);
           }
         continue;
@@ -95,8 +95,8 @@ void cmLBDepend::DependWalk(cmDependInformation* info)
           found = true;
           }
         for(std::vector<std::string>::iterator i = 
-              m_IncludeDirectories.begin();
-            i != m_IncludeDirectories.end(); ++i)
+              this->IncludeDirectories.begin();
+            i != this->IncludeDirectories.end(); ++i)
           {
           std::string path = *i;
           path = path + "/";
@@ -114,8 +114,8 @@ void cmLBDepend::DependWalk(cmDependInformation* info)
             found = true;
             }
           for(std::vector<std::string>::iterator i = 
-                m_IncludeDirectories.begin();
-              i != m_IncludeDirectories.end(); ++i)
+                this->IncludeDirectories.begin();
+              i != this->IncludeDirectories.end(); ++i)
             {
             std::string path = *i;
             path = path + "/";
@@ -134,8 +134,8 @@ void cmLBDepend::DependWalk(cmDependInformation* info)
             found = true;
             }
           for(std::vector<std::string>::iterator i = 
-                m_IncludeDirectories.begin();
-              i != m_IncludeDirectories.end(); ++i)
+                this->IncludeDirectories.begin();
+              i != this->IncludeDirectories.end(); ++i)
             {
             std::string path = *i;
             path = path + "/";
@@ -154,8 +154,8 @@ void cmLBDepend::DependWalk(cmDependInformation* info)
             found = true;
             }
           for(std::vector<std::string>::iterator i = 
-                m_IncludeDirectories.begin();
-              i != m_IncludeDirectories.end(); ++i)
+                this->IncludeDirectories.begin();
+              i != this->IncludeDirectories.end(); ++i)
             {
             std::string path = *i;
             path = path + "/";
@@ -185,8 +185,8 @@ bool cmOutputRequiredFilesCommand::InitialPass(std::vector<std::string> const& a
     }
 
   // store the arg for final pass
-  m_File = args[0];
-  m_OutputFile = args[1];
+  this->File = args[0];
+  this->OutputFile = args[1];
   
   return true;
 }
@@ -199,20 +199,20 @@ ListDependencies(cmDependInformation const *info,
   // add info to the visited set
   visited->insert(info);
   // now recurse with info's dependencies
-  for(cmDependInformation::DependencySet::const_iterator d = 
-        info->m_DependencySet.begin();
-      d != info->m_DependencySet.end(); ++d)
+  for(cmDependInformation::DependencySetType::const_iterator d = 
+        info->DependencySet.begin();
+      d != info->DependencySet.end(); ++d)
     {
     if (visited->find(*d) == visited->end())
       {
-      if(info->m_FullPath != "")
+      if(info->FullPath != "")
         {
-        std::string tmp = (*d)->m_FullPath;
+        std::string tmp = (*d)->FullPath;
         std::string::size_type pos = tmp.rfind('.');
         if(pos != std::string::npos && (tmp.substr(pos) != ".h"))
           {
           tmp = tmp.substr(0, pos);
-          fprintf(fout,"%s\n",(*d)->m_FullPath.c_str());
+          fprintf(fout,"%s\n",(*d)->FullPath.c_str());
           }
         }
       this->ListDependencies(*d,fout,visited);
@@ -223,22 +223,22 @@ ListDependencies(cmDependInformation const *info,
 void cmOutputRequiredFilesCommand::FinalPass()
 {
   
-  cmTargets &tgts = m_Makefile->GetTargets();
+  cmTargets &tgts = this->Makefile->GetTargets();
   for (cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
     {
-    l->second.GenerateSourceFilesFromSourceLists(*m_Makefile);
+    l->second.GenerateSourceFilesFromSourceLists(*this->Makefile);
     }
 
   // compute the list of files
   cmLBDepend md;
-  md.SetMakefile(m_Makefile);
-  md.AddSearchPath(m_Makefile->GetStartDirectory());
+  md.SetMakefile(this->Makefile);
+  md.AddSearchPath(this->Makefile->GetStartDirectory());
   // find the depends for a file
-  const cmDependInformation *info = md.FindDependencies(m_File.c_str());
+  const cmDependInformation *info = md.FindDependencies(this->File.c_str());
   if (info)
     {
     // write them out
-    FILE *fout = fopen(m_OutputFile.c_str(),"w");
+    FILE *fout = fopen(this->OutputFile.c_str(),"w");
     std::set<cmDependInformation const*> visited;
     this->ListDependencies(info,fout, &visited);
     fclose(fout);
diff --git a/Source/cmOutputRequiredFilesCommand.h b/Source/cmOutputRequiredFilesCommand.h
index 3df2ace..338b271 100644
--- a/Source/cmOutputRequiredFilesCommand.h
+++ b/Source/cmOutputRequiredFilesCommand.h
@@ -76,8 +76,8 @@ public:
                         std::set<cmDependInformation const*> *visited);
 
 private:
-  std::string m_File;
-  std::string m_OutputFile;
+  std::string File;
+  std::string OutputFile;
 };
 
 
diff --git a/Source/cmProjectCommand.cxx b/Source/cmProjectCommand.cxx
index 627789f..bdbafbf 100644
--- a/Source/cmProjectCommand.cxx
+++ b/Source/cmProjectCommand.cxx
@@ -24,36 +24,36 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args)
     this->SetError("PROJECT called with incorrect number of arguments");
     return false;
     } 
-  m_Makefile->SetProjectName(args[0].c_str());
+  this->Makefile->SetProjectName(args[0].c_str());
 
   std::string bindir = args[0];
   bindir += "_BINARY_DIR";
   std::string srcdir = args[0];
   srcdir += "_SOURCE_DIR";
   
-  m_Makefile->AddCacheDefinition(bindir.c_str(),
-                                 m_Makefile->GetCurrentOutputDirectory(),
+  this->Makefile->AddCacheDefinition(bindir.c_str(),
+                                 this->Makefile->GetCurrentOutputDirectory(),
                                  "Value Computed by CMake", cmCacheManager::STATIC);
-  m_Makefile->AddCacheDefinition(srcdir.c_str(),
-                                 m_Makefile->GetCurrentDirectory(),
+  this->Makefile->AddCacheDefinition(srcdir.c_str(),
+                                 this->Makefile->GetCurrentDirectory(),
                                  "Value Computed by CMake", cmCacheManager::STATIC);
   
   bindir = "PROJECT_BINARY_DIR";
   srcdir = "PROJECT_SOURCE_DIR";
 
-  m_Makefile->AddDefinition(bindir.c_str(),
-          m_Makefile->GetCurrentOutputDirectory());
-  m_Makefile->AddDefinition(srcdir.c_str(),
-          m_Makefile->GetCurrentDirectory());
+  this->Makefile->AddDefinition(bindir.c_str(),
+          this->Makefile->GetCurrentOutputDirectory());
+  this->Makefile->AddDefinition(srcdir.c_str(),
+          this->Makefile->GetCurrentDirectory());
 
-  m_Makefile->AddDefinition("PROJECT_NAME", args[0].c_str());
+  this->Makefile->AddDefinition("PROJECT_NAME", args[0].c_str());
 
   // Set the CMAKE_PROJECT_NAME variable to be the highest-level
   // project name in the tree.  This is always the first PROJECT
   // command encountered.
-  if(!m_Makefile->GetDefinition("CMAKE_PROJECT_NAME"))
+  if(!this->Makefile->GetDefinition("CMAKE_PROJECT_NAME"))
     {
-    m_Makefile->AddDefinition("CMAKE_PROJECT_NAME", args[0].c_str());
+    this->Makefile->AddDefinition("CMAKE_PROJECT_NAME", args[0].c_str());
     }
 
   std::vector<std::string> languages;
@@ -70,7 +70,7 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args)
     languages.push_back("C");
     languages.push_back("CXX");
     }
-  m_Makefile->EnableLanguage(languages);
+  this->Makefile->EnableLanguage(languages);
   return true;
 }
 
diff --git a/Source/cmQTWrapCPPCommand.cxx b/Source/cmQTWrapCPPCommand.cxx
index 4a3fd8a..0ddf382 100644
--- a/Source/cmQTWrapCPPCommand.cxx
+++ b/Source/cmQTWrapCPPCommand.cxx
@@ -25,19 +25,19 @@ bool cmQTWrapCPPCommand::InitialPass(std::vector<std::string> const& argsIn)
     return false;
     }
   std::vector<std::string> args;
-  m_Makefile->ExpandSourceListArguments(argsIn, args, 2);
+  this->Makefile->ExpandSourceListArguments(argsIn, args, 2);
 
   // what is the current source dir
-  std::string cdir = m_Makefile->GetCurrentDirectory();
+  std::string cdir = this->Makefile->GetCurrentDirectory();
 
   // keep the library name
-  m_LibraryName = args[0];
-  m_SourceList = args[1];
+  this->LibraryName = args[0];
+  this->SourceList = args[1];
   
   std::string sourceListValue;
 
   // was the list already populated
-  const char *def = m_Makefile->GetDefinition(m_SourceList.c_str());  
+  const char *def = this->Makefile->GetDefinition(this->SourceList.c_str());  
   if (def)
     {
     sourceListValue = def;
@@ -47,7 +47,7 @@ bool cmQTWrapCPPCommand::InitialPass(std::vector<std::string> const& argsIn)
   for(std::vector<std::string>::iterator j = (args.begin() + 2);
       j != args.end(); ++j)
     {   
-    cmSourceFile *curr = m_Makefile->GetSource(j->c_str());
+    cmSourceFile *curr = this->Makefile->GetSource(j->c_str());
     
     // if we should wrap the class
     if (!curr || !curr->GetPropertyAsBool("WRAP_EXCLUDE"))
@@ -59,7 +59,7 @@ bool cmQTWrapCPPCommand::InitialPass(std::vector<std::string> const& argsIn)
         }
       std::string srcName = cmSystemTools::GetFilenameWithoutLastExtension(*j);
       std::string newName = "moc_" + srcName;
-      file.SetName(newName.c_str(), m_Makefile->GetCurrentOutputDirectory(),
+      file.SetName(newName.c_str(), this->Makefile->GetCurrentOutputDirectory(),
                    "cxx",false);
       std::string hname;
       if ( (*j)[0] == '/' || (*j)[1] == ':' )
@@ -70,17 +70,17 @@ bool cmQTWrapCPPCommand::InitialPass(std::vector<std::string> const& argsIn)
         {
         if ( curr && curr->GetPropertyAsBool("GENERATED") )
           {
-          hname = std::string( m_Makefile->GetCurrentOutputDirectory() ) + "/" + *j;
+          hname = std::string( this->Makefile->GetCurrentOutputDirectory() ) + "/" + *j;
           }
         else
           {
           hname = cdir + "/" + *j;
           }
         }
-      m_WrapHeaders.push_back(hname);
+      this->WrapHeaders.push_back(hname);
       // add starting depends
       file.GetDepends().push_back(hname);
-      m_WrapClasses.push_back(file);
+      this->WrapClasses.push_back(file);
       if (sourceListValue.size() > 0)
         {
         sourceListValue += ";";
@@ -89,7 +89,7 @@ bool cmQTWrapCPPCommand::InitialPass(std::vector<std::string> const& argsIn)
       }
     }
   
-  m_Makefile->AddDefinition(m_SourceList.c_str(), sourceListValue.c_str());
+  this->Makefile->AddDefinition(this->SourceList.c_str(), sourceListValue.c_str());
   return true;
 }
 
@@ -97,9 +97,9 @@ void cmQTWrapCPPCommand::FinalPass()
 {
 
   // first we add the rules for all the .h to Moc files
-  size_t lastClass = m_WrapClasses.size();
+  size_t lastClass = this->WrapClasses.size();
   std::vector<std::string> depends;
-  const char* moc_exe = m_Makefile->GetRequiredDefinition("QT_MOC_EXECUTABLE");
+  const char* moc_exe = this->Makefile->GetRequiredDefinition("QT_MOC_EXECUTABLE");
 
   // wrap all the .h files
   depends.push_back(moc_exe);
@@ -107,28 +107,28 @@ void cmQTWrapCPPCommand::FinalPass()
   for(size_t classNum = 0; classNum < lastClass; classNum++)
     {
     // Add output to build list
-    m_Makefile->AddSource(m_WrapClasses[classNum]);
+    this->Makefile->AddSource(this->WrapClasses[classNum]);
 
     // set up moc command
-    std::string res = m_Makefile->GetCurrentOutputDirectory();
+    std::string res = this->Makefile->GetCurrentOutputDirectory();
     res += "/";
-    res += m_WrapClasses[classNum].GetSourceName() + ".cxx";
+    res += this->WrapClasses[classNum].GetSourceName() + ".cxx";
 
     cmCustomCommandLine commandLine;
     commandLine.push_back(moc_exe);
     commandLine.push_back("-o");
     commandLine.push_back(res);
-    commandLine.push_back(m_WrapHeaders[classNum]);
+    commandLine.push_back(this->WrapHeaders[classNum]);
 
     cmCustomCommandLines commandLines;
     commandLines.push_back(commandLine);
 
     std::vector<std::string> realdepends = depends;
-    realdepends.push_back(m_WrapHeaders[classNum]);
+    realdepends.push_back(this->WrapHeaders[classNum]);
 
     const char* no_main_dependency = 0;
     const char* no_working_dir = 0;
-    m_Makefile->AddCustomCommandToOutput(res.c_str(),
+    this->Makefile->AddCustomCommandToOutput(res.c_str(),
                                          realdepends,
                                          no_main_dependency,
                                          commandLines,
diff --git a/Source/cmQTWrapCPPCommand.h b/Source/cmQTWrapCPPCommand.h
index 46d50d3..6f3e95d 100644
--- a/Source/cmQTWrapCPPCommand.h
+++ b/Source/cmQTWrapCPPCommand.h
@@ -83,13 +83,13 @@ private:
   /**
    * List of produced files.
    */
-  std::vector<cmSourceFile> m_WrapClasses;
+  std::vector<cmSourceFile> WrapClasses;
   /**
-   * List of header files that pprovide the source for m_WrapClasses.
+   * List of header files that pprovide the source for WrapClasses.
    */
-  std::vector<std::string> m_WrapHeaders;
-  std::string m_LibraryName;
-  std::string m_SourceList;
+  std::vector<std::string> WrapHeaders;
+  std::string LibraryName;
+  std::string SourceList;
 };
 
 
diff --git a/Source/cmQTWrapUICommand.cxx b/Source/cmQTWrapUICommand.cxx
index cb15cfd..717459c 100644
--- a/Source/cmQTWrapUICommand.cxx
+++ b/Source/cmQTWrapUICommand.cxx
@@ -25,18 +25,18 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& argsIn)
     return false;
     }
   std::vector<std::string> args;
-  m_Makefile->ExpandSourceListArguments(argsIn, args, 3);
+  this->Makefile->ExpandSourceListArguments(argsIn, args, 3);
 
   // what is the current source dir
-  std::string cdir = m_Makefile->GetCurrentDirectory();
+  std::string cdir = this->Makefile->GetCurrentDirectory();
 
   // keep the library name
-  m_LibraryName = args[0];
-  m_HeaderList = args[1];
-  m_SourceList = args[2];
+  this->LibraryName = args[0];
+  this->HeaderList = args[1];
+  this->SourceList = args[2];
   std::string sourceListValue;
   std::string headerListValue;
-  const char *def = m_Makefile->GetDefinition(m_SourceList.c_str());  
+  const char *def = this->Makefile->GetDefinition(this->SourceList.c_str());  
   if (def)
     {
     sourceListValue = def;
@@ -46,7 +46,7 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& argsIn)
   for(std::vector<std::string>::iterator j = (args.begin() + 3);
       j != args.end(); ++j)
     {   
-    cmSourceFile *curr = m_Makefile->GetSource(j->c_str());
+    cmSourceFile *curr = this->Makefile->GetSource(j->c_str());
     
     // if we should wrap the class
     if (!curr || !curr->GetPropertyAsBool("WRAP_EXCLUDE"))
@@ -56,15 +56,15 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& argsIn)
       cmSourceFile moc_file;
       std::string srcName = cmSystemTools::GetFilenameWithoutExtension(*j);
       header_file.SetName(srcName.c_str(), 
-                          m_Makefile->GetCurrentOutputDirectory(),
+                          this->Makefile->GetCurrentOutputDirectory(),
                           "h",false);
       source_file.SetName(srcName.c_str(), 
-                          m_Makefile->GetCurrentOutputDirectory(),
+                          this->Makefile->GetCurrentOutputDirectory(),
                           "cxx",false);
       std::string moc_source_name("moc_");
       moc_source_name = moc_source_name + srcName;
       moc_file.SetName(moc_source_name.c_str(), 
-                       m_Makefile->GetCurrentOutputDirectory(),
+                       this->Makefile->GetCurrentOutputDirectory(),
                        "cxx",false);
       std::string origname;
       if ( (*j)[0] == '/' || (*j)[1] == ':' )
@@ -75,7 +75,7 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& argsIn)
         {
         if ( curr && curr->GetPropertyAsBool("GENERATED") )
           {
-          origname = std::string( m_Makefile->GetCurrentOutputDirectory() ) + "/" + *j;
+          origname = std::string( this->Makefile->GetCurrentOutputDirectory() ) + "/" + *j;
           }
         else
           {
@@ -83,18 +83,18 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& argsIn)
           }
         }
       std::string hname = header_file.GetFullPath();
-      m_WrapUserInterface.push_back(origname);
+      this->WrapUserInterface.push_back(origname);
       // add starting depends
       moc_file.GetDepends().push_back(hname);
       source_file.GetDepends().push_back(hname);
       source_file.GetDepends().push_back(origname);
       header_file.GetDepends().push_back(origname);
-      m_WrapHeadersClasses.push_back(header_file);
-      m_WrapSourcesClasses.push_back(source_file);
-      m_WrapMocClasses.push_back(moc_file);
-      m_Makefile->AddSource(header_file);
-      m_Makefile->AddSource(source_file);
-      m_Makefile->AddSource(moc_file);
+      this->WrapHeadersClasses.push_back(header_file);
+      this->WrapSourcesClasses.push_back(source_file);
+      this->WrapMocClasses.push_back(moc_file);
+      this->Makefile->AddSource(header_file);
+      this->Makefile->AddSource(source_file);
+      this->Makefile->AddSource(moc_file);
       
       // create the list of headers 
       if (headerListValue.size() > 0)
@@ -114,8 +114,8 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& argsIn)
       }
     }
   
-  m_Makefile->AddDefinition(m_SourceList.c_str(), sourceListValue.c_str());  
-  m_Makefile->AddDefinition(m_HeaderList.c_str(), headerListValue.c_str());  
+  this->Makefile->AddDefinition(this->SourceList.c_str(), sourceListValue.c_str());  
+  this->Makefile->AddDefinition(this->HeaderList.c_str(), headerListValue.c_str());  
   return true;
 }
 
@@ -123,10 +123,10 @@ void cmQTWrapUICommand::FinalPass()
 {
 
   // first we add the rules for all the .ui to .h and .cxx files
-  size_t lastHeadersClass = m_WrapHeadersClasses.size();
+  size_t lastHeadersClass = this->WrapHeadersClasses.size();
   std::vector<std::string> depends;
-  const char* uic_exe = m_Makefile->GetRequiredDefinition("QT_UIC_EXECUTABLE");
-  const char* moc_exe = m_Makefile->GetRequiredDefinition("QT_MOC_EXECUTABLE");
+  const char* uic_exe = this->Makefile->GetRequiredDefinition("QT_UIC_EXECUTABLE");
+  const char* moc_exe = this->Makefile->GetRequiredDefinition("QT_MOC_EXECUTABLE");
 
   // wrap all the .h files
   depends.push_back(uic_exe);
@@ -134,26 +134,26 @@ void cmQTWrapUICommand::FinalPass()
   for(size_t classNum = 0; classNum < lastHeadersClass; classNum++)
     {
     // set up .ui to .h and .cxx command
-    std::string hres = m_Makefile->GetCurrentOutputDirectory();
+    std::string hres = this->Makefile->GetCurrentOutputDirectory();
     hres += "/";
-    hres += m_WrapHeadersClasses[classNum].GetSourceName() + "." +
-        m_WrapHeadersClasses[classNum].GetSourceExtension();
+    hres += this->WrapHeadersClasses[classNum].GetSourceName() + "." +
+        this->WrapHeadersClasses[classNum].GetSourceExtension();
 
-    std::string cxxres = m_Makefile->GetCurrentOutputDirectory();
+    std::string cxxres = this->Makefile->GetCurrentOutputDirectory();
     cxxres += "/";
-    cxxres += m_WrapSourcesClasses[classNum].GetSourceName() + "." +
-        m_WrapSourcesClasses[classNum].GetSourceExtension();
+    cxxres += this->WrapSourcesClasses[classNum].GetSourceName() + "." +
+        this->WrapSourcesClasses[classNum].GetSourceExtension();
 
-    std::string mocres = m_Makefile->GetCurrentOutputDirectory();
+    std::string mocres = this->Makefile->GetCurrentOutputDirectory();
     mocres += "/";
-    mocres += m_WrapMocClasses[classNum].GetSourceName() + "." +
-        m_WrapMocClasses[classNum].GetSourceExtension();
+    mocres += this->WrapMocClasses[classNum].GetSourceName() + "." +
+        this->WrapMocClasses[classNum].GetSourceExtension();
 
     cmCustomCommandLine hCommand;
     hCommand.push_back(uic_exe);
     hCommand.push_back("-o");
     hCommand.push_back(hres);
-    hCommand.push_back(m_WrapUserInterface[classNum]);
+    hCommand.push_back(this->WrapUserInterface[classNum]);
     cmCustomCommandLines hCommandLines;
     hCommandLines.push_back(hCommand);
 
@@ -163,7 +163,7 @@ void cmQTWrapUICommand::FinalPass()
     cxxCommand.push_back(hres);
     cxxCommand.push_back("-o");
     cxxCommand.push_back(cxxres);
-    cxxCommand.push_back(m_WrapUserInterface[classNum]);
+    cxxCommand.push_back(this->WrapUserInterface[classNum]);
     cmCustomCommandLines cxxCommandLines;
     cxxCommandLines.push_back(cxxCommand);
 
@@ -176,11 +176,11 @@ void cmQTWrapUICommand::FinalPass()
     mocCommandLines.push_back(mocCommand);
 
     depends.clear();
-    depends.push_back(m_WrapUserInterface[classNum]);
+    depends.push_back(this->WrapUserInterface[classNum]);
     const char* no_main_dependency = 0;
     const char* no_comment = 0;
     const char* no_working_dir = 0;
-    m_Makefile->AddCustomCommandToOutput(hres.c_str(),
+    this->Makefile->AddCustomCommandToOutput(hres.c_str(),
                                          depends,
                                          no_main_dependency,
                                          hCommandLines,
@@ -189,7 +189,7 @@ void cmQTWrapUICommand::FinalPass()
 
     depends.push_back(hres);
 
-    m_Makefile->AddCustomCommandToOutput(cxxres.c_str(),
+    this->Makefile->AddCustomCommandToOutput(cxxres.c_str(),
                                          depends,
                                          no_main_dependency,
                                          cxxCommandLines,
@@ -199,7 +199,7 @@ void cmQTWrapUICommand::FinalPass()
     depends.clear();
     depends.push_back(hres);
 
-    m_Makefile->AddCustomCommandToOutput(mocres.c_str(),
+    this->Makefile->AddCustomCommandToOutput(mocres.c_str(),
                                          depends,
                                          no_main_dependency,
                                          mocCommandLines,
diff --git a/Source/cmQTWrapUICommand.h b/Source/cmQTWrapUICommand.h
index 02b29f4..2b4b866 100644
--- a/Source/cmQTWrapUICommand.h
+++ b/Source/cmQTWrapUICommand.h
@@ -85,16 +85,16 @@ private:
   /**
    * List of produced files.
    */
-  std::vector<cmSourceFile> m_WrapSourcesClasses;
-  std::vector<cmSourceFile> m_WrapHeadersClasses;
-  std::vector<cmSourceFile> m_WrapMocClasses;
+  std::vector<cmSourceFile> WrapSourcesClasses;
+  std::vector<cmSourceFile> WrapHeadersClasses;
+  std::vector<cmSourceFile> WrapMocClasses;
   /**
-   * List of header files that pprovide the source for m_WrapClasses.
+   * List of header files that pprovide the source for WrapClasses.
    */
-  std::vector<std::string> m_WrapUserInterface;
-  std::string m_LibraryName;
-  std::string m_HeaderList;
-  std::string m_SourceList;
+  std::vector<std::string> WrapUserInterface;
+  std::string LibraryName;
+  std::string HeaderList;
+  std::string SourceList;
 };
 
 
diff --git a/Source/cmRemoveCommand.cxx b/Source/cmRemoveCommand.cxx
index a0471a7..94388c0 100644
--- a/Source/cmRemoveCommand.cxx
+++ b/Source/cmRemoveCommand.cxx
@@ -27,7 +27,7 @@ bool cmRemoveCommand::InitialPass(std::vector<std::string> const& args)
   const char* variable = args[0].c_str(); // VAR is always first
   // get the old value
   const char* cacheValue
-    = m_Makefile->GetDefinition(variable);
+    = this->Makefile->GetDefinition(variable);
 
   // if there is no old value then return
   if (!cacheValue)
@@ -73,7 +73,7 @@ bool cmRemoveCommand::InitialPass(std::vector<std::string> const& args)
     }
   
   // add the definition
-  m_Makefile->AddDefinition(variable, value.c_str());
+  this->Makefile->AddDefinition(variable, value.c_str());
 
   return true;
 }
diff --git a/Source/cmRemoveDefinitionsCommand.cxx b/Source/cmRemoveDefinitionsCommand.cxx
index 1532742..918b1f4 100644
--- a/Source/cmRemoveDefinitionsCommand.cxx
+++ b/Source/cmRemoveDefinitionsCommand.cxx
@@ -28,7 +28,7 @@ bool cmRemoveDefinitionsCommand::InitialPass(std::vector<std::string> const& arg
   for(std::vector<std::string>::const_iterator i = args.begin();
       i != args.end(); ++i)
     {
-    m_Makefile->RemoveDefineFlag(i->c_str());
+    this->Makefile->RemoveDefineFlag(i->c_str());
     }
   return true;
 }
diff --git a/Source/cmSeparateArgumentsCommand.cxx b/Source/cmSeparateArgumentsCommand.cxx
index efb313e..17e08a9 100644
--- a/Source/cmSeparateArgumentsCommand.cxx
+++ b/Source/cmSeparateArgumentsCommand.cxx
@@ -24,7 +24,7 @@ bool cmSeparateArgumentsCommand::InitialPass(std::vector<std::string> const& arg
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  const char* cacheValue = m_Makefile->GetDefinition(args[0].c_str());
+  const char* cacheValue = this->Makefile->GetDefinition(args[0].c_str());
   if(!cacheValue)
     {
     return true;
@@ -32,7 +32,7 @@ bool cmSeparateArgumentsCommand::InitialPass(std::vector<std::string> const& arg
   std::string value = cacheValue;
   cmSystemTools::ReplaceString(value,
                                " ", ";");
-  m_Makefile->AddDefinition(args[0].c_str(), value.c_str());
+  this->Makefile->AddDefinition(args[0].c_str(), value.c_str());
   return true;
 }
 
diff --git a/Source/cmSetCommand.cxx b/Source/cmSetCommand.cxx
index 548cec4..c0bf6ce 100644
--- a/Source/cmSetCommand.cxx
+++ b/Source/cmSetCommand.cxx
@@ -63,7 +63,7 @@ bool cmSetCommand::InitialPass(std::vector<std::string> const& args)
   // SET (VAR) // Removes the definition of VAR.
   if (args.size() == 1)
     {
-    m_Makefile->RemoveDefinition(args[0].c_str());
+    this->Makefile->RemoveDefinition(args[0].c_str());
     return true;
     }
 
@@ -134,7 +134,7 @@ bool cmSetCommand::InitialPass(std::vector<std::string> const& args)
 
   // see if this is already in the cache
   cmCacheManager::CacheIterator it = 
-    m_Makefile->GetCacheManager()->GetCacheIterator(variable);
+    this->Makefile->GetCacheManager()->GetCacheIterator(variable);
   if(!it.IsAtEnd() && (it.GetType() != cmCacheManager::UNINITIALIZED))
     {
     // if the set is trying to CACHE the value but the value
@@ -150,7 +150,7 @@ bool cmSetCommand::InitialPass(std::vector<std::string> const& args)
   // if it is meant to be in the cache then define it in the cache
   if(cache)
     {
-    m_Makefile->AddCacheDefinition(variable,
+    this->Makefile->AddCacheDefinition(variable,
                                    value.c_str(),
                                    docstring,
                                    type);
@@ -158,7 +158,7 @@ bool cmSetCommand::InitialPass(std::vector<std::string> const& args)
   else
     {
     // add the definition
-    m_Makefile->AddDefinition(variable, value.c_str());
+    this->Makefile->AddDefinition(variable, value.c_str());
     }
   return true;
 }
diff --git a/Source/cmSetDirectoryPropertiesCommand.cxx b/Source/cmSetDirectoryPropertiesCommand.cxx
index 1c3049c..3fb1178 100644
--- a/Source/cmSetDirectoryPropertiesCommand.cxx
+++ b/Source/cmSetDirectoryPropertiesCommand.cxx
@@ -54,29 +54,29 @@ bool cmSetDirectoryPropertiesCommand::InitialPass(
       {
       std::vector<std::string> varArgsExpanded;
       cmSystemTools::ExpandListArgument(value, varArgsExpanded);
-      m_Makefile->SetIncludeDirectories(varArgsExpanded);
+      this->Makefile->SetIncludeDirectories(varArgsExpanded);
       }
     else if ( prop == "LINK_DIRECTORIES" )
       {
       std::vector<std::string> varArgsExpanded;
       cmSystemTools::ExpandListArgument(value, varArgsExpanded);
-      m_Makefile->SetLinkDirectories(varArgsExpanded);
+      this->Makefile->SetLinkDirectories(varArgsExpanded);
       }
     else if ( prop == "INCLUDE_REGULAR_EXPRESSION" )
       {
-      m_Makefile->SetIncludeRegularExpression(value.c_str());
+      this->Makefile->SetIncludeRegularExpression(value.c_str());
       }
     else
       {
       if ( prop == "ADDITIONAL_MAKE_CLEAN_FILES" )
         {
         // This property is not inherrited
-        if ( strcmp(m_Makefile->GetCurrentDirectory(), m_Makefile->GetStartDirectory()) != 0 )
+        if ( strcmp(this->Makefile->GetCurrentDirectory(), this->Makefile->GetStartDirectory()) != 0 )
           {
           continue;
           }
         }
-      m_Makefile->SetProperty(prop.c_str(), value.c_str());
+      this->Makefile->SetProperty(prop.c_str(), value.c_str());
       }
     }
   
diff --git a/Source/cmSetSourceFilesPropertiesCommand.cxx b/Source/cmSetSourceFilesPropertiesCommand.cxx
index 4ce53a5..377eb73 100644
--- a/Source/cmSetSourceFilesPropertiesCommand.cxx
+++ b/Source/cmSetSourceFilesPropertiesCommand.cxx
@@ -129,7 +129,7 @@ bool cmSetSourceFilesPropertiesCommand::InitialPass(
     {   
     // get the source file
     cmSourceFile* sf =
-      m_Makefile->GetOrCreateSource(args[i].c_str(), generated);
+      this->Makefile->GetOrCreateSource(args[i].c_str(), generated);
     if(sf)
       {
       // now loop through all the props and set them
diff --git a/Source/cmSetTargetPropertiesCommand.cxx b/Source/cmSetTargetPropertiesCommand.cxx
index 41fce79..abf3daf 100644
--- a/Source/cmSetTargetPropertiesCommand.cxx
+++ b/Source/cmSetTargetPropertiesCommand.cxx
@@ -69,7 +69,7 @@ bool cmSetTargetPropertiesCommand::InitialPass(
      return false;
     }
   
-  cmTargets& targets = m_Makefile->GetTargets();
+  cmTargets& targets = this->Makefile->GetTargets();
   // now loop over all the targets
   int i;
   unsigned int k;
diff --git a/Source/cmSetTestsPropertiesCommand.cxx b/Source/cmSetTestsPropertiesCommand.cxx
index 65d82f0..c39f722 100644
--- a/Source/cmSetTestsPropertiesCommand.cxx
+++ b/Source/cmSetTestsPropertiesCommand.cxx
@@ -72,7 +72,7 @@ bool cmSetTestsPropertiesCommand::InitialPass(
     return false;
     }
 
-  std::vector<cmTest*> &tests = *m_Makefile->GetTests();
+  std::vector<cmTest*> &tests = *this->Makefile->GetTests();
   // now loop over all the targets
   int i;
   unsigned int k;
diff --git a/Source/cmSiteNameCommand.cxx b/Source/cmSiteNameCommand.cxx
index b949aeb..845a40d 100644
--- a/Source/cmSiteNameCommand.cxx
+++ b/Source/cmSiteNameCommand.cxx
@@ -35,13 +35,13 @@ bool cmSiteNameCommand::InitialPass(std::vector<std::string> const& args)
   paths.push_back("/usr/local/bin");
   
   const char* cacheValue
-    = m_Makefile->GetDefinition(args[0].c_str());
+    = this->Makefile->GetDefinition(args[0].c_str());
   if(cacheValue)
     {
     return true;
     }
   
-  const char *temp = m_Makefile->GetDefinition("HOSTNAME");
+  const char *temp = this->Makefile->GetDefinition("HOSTNAME");
   std::string hostname_cmd;
   if(temp)
     {
@@ -88,7 +88,7 @@ bool cmSiteNameCommand::InitialPass(std::vector<std::string> const& args)
       }
     }
 #endif
-  m_Makefile->
+  this->Makefile->
     AddCacheDefinition(args[0].c_str(),
                        siteName.c_str(),
                        "Name of the computer/site where compile is being run",
diff --git a/Source/cmSourceFile.cxx b/Source/cmSourceFile.cxx
index e638d26..ac9f28b 100644
--- a/Source/cmSourceFile.cxx
+++ b/Source/cmSourceFile.cxx
@@ -29,10 +29,10 @@ void cmSourceFile::SetName(const char* name, const char* dir,
 {
 
   this->SetProperty("HEADER_FILE_ONLY","1");
-  m_SourceNameWithoutLastExtension = "";
+  this->SourceNameWithoutLastExtension = "";
 
   // Save the original name given.
-  m_SourceName = name;
+  this->SourceName = name;
 
   // Convert the name to a full path in case the given name is a
   // relative path.
@@ -43,39 +43,39 @@ void cmSourceFile::SetName(const char* name, const char* dir,
   std::string hname = pathname;
   if(cmSystemTools::FileExists(hname.c_str()))
     {
-    m_SourceName = cmSystemTools::GetFilenamePath(name);
-    if ( m_SourceName.size() > 0 )
+    this->SourceName = cmSystemTools::GetFilenamePath(name);
+    if ( this->SourceName.size() > 0 )
       {
-      m_SourceName += "/";
+      this->SourceName += "/";
       }
-    m_SourceName += cmSystemTools::GetFilenameWithoutLastExtension(name);
+    this->SourceName += cmSystemTools::GetFilenameWithoutLastExtension(name);
     std::string::size_type pos = hname.rfind('.');
     if(pos != std::string::npos)
       {
-      m_SourceExtension = hname.substr(pos+1, hname.size()-pos);
+      this->SourceExtension = hname.substr(pos+1, hname.size()-pos);
       if ( cmSystemTools::FileIsFullPath(name) )
         {
         std::string::size_type pos2 = hname.rfind('/');
         if(pos2 != std::string::npos)
           {
-          m_SourceName = hname.substr(pos2+1, pos - pos2-1);
+          this->SourceName = hname.substr(pos2+1, pos - pos2-1);
           }
         }
       }
 
     // See if the file is a header file
-    if(std::find( headerExts.begin(), headerExts.end(), m_SourceExtension ) ==
+    if(std::find( headerExts.begin(), headerExts.end(), this->SourceExtension ) ==
       headerExts.end())
       {
       this->SetProperty("HEADER_FILE_ONLY","0");
       }
-    m_FullPath = hname;
+    this->FullPath = hname;
 
     // Mark this as an external object file if it has the proper
     // extension.  THIS CODE IS DUPLICATED IN THE OTHER SetName METHOD.
     // THESE METHODS SHOULD BE MERGED.
-    if ( m_SourceExtension == "obj" || m_SourceExtension == "o" ||
-      m_SourceExtension == "lo" )
+    if ( this->SourceExtension == "obj" || this->SourceExtension == "o" ||
+      this->SourceExtension == "lo" )
       {
       this->SetProperty("EXTERNAL_OBJECT", "1");
       }
@@ -91,9 +91,9 @@ void cmSourceFile::SetName(const char* name, const char* dir,
     hname += *ext;
     if(cmSystemTools::FileExists(hname.c_str()))
       {
-      m_SourceExtension = *ext;
+      this->SourceExtension = *ext;
       this->SetProperty("HEADER_FILE_ONLY","0");
-      m_FullPath = hname;
+      this->FullPath = hname;
       return;
       }
     }
@@ -107,8 +107,8 @@ void cmSourceFile::SetName(const char* name, const char* dir,
     hname += *ext;
     if(cmSystemTools::FileExists(hname.c_str()))
       {
-      m_SourceExtension = *ext;
-      m_FullPath = hname;
+      this->SourceExtension = *ext;
+      this->FullPath = hname;
       return;
       }
     }
@@ -134,23 +134,23 @@ void cmSourceFile::SetName(const char* name, const char* dir, const char *ext,
                            bool hfo)
 {
   this->SetProperty("HEADER_FILE_ONLY",(hfo ? "1" : "0"));
-  m_SourceNameWithoutLastExtension = "";
-  m_SourceName = name;
-  std::string fname = m_SourceName;
+  this->SourceNameWithoutLastExtension = "";
+  this->SourceName = name;
+  std::string fname = this->SourceName;
   if(ext && strlen(ext))
     {
     fname += ".";
     fname += ext;
     }
-  m_FullPath = cmSystemTools::CollapseFullPath(fname.c_str(), dir);
-  cmSystemTools::ConvertToUnixSlashes(m_FullPath);
-  m_SourceExtension = ext;
+  this->FullPath = cmSystemTools::CollapseFullPath(fname.c_str(), dir);
+  cmSystemTools::ConvertToUnixSlashes(this->FullPath);
+  this->SourceExtension = ext;
 
   // Mark this as an external object file if it has the proper
   // extension.  THIS CODE IS DUPLICATED IN THE OTHER SetName METHOD.
   // THESE METHODS SHOULD BE MERGED.
-  if ( m_SourceExtension == "obj" || m_SourceExtension == "o" ||
-       m_SourceExtension == "lo" )
+  if ( this->SourceExtension == "obj" || this->SourceExtension == "o" ||
+       this->SourceExtension == "lo" )
     {
     this->SetProperty("EXTERNAL_OBJECT", "1");
     }
@@ -159,9 +159,9 @@ void cmSourceFile::SetName(const char* name, const char* dir, const char *ext,
 
 void cmSourceFile::Print() const
 {
-  std::cerr << "m_FullPath: " <<  m_FullPath << "\n";
-  std::cerr << "m_SourceName: " << m_SourceName << std::endl;
-  std::cerr << "m_SourceExtension: " << m_SourceExtension << "\n";
+  std::cerr << "this->FullPath: " <<  this->FullPath << "\n";
+  std::cerr << "this->SourceName: " << this->SourceName << std::endl;
+  std::cerr << "this->SourceExtension: " << this->SourceExtension << "\n";
 }
 
 void cmSourceFile::SetProperty(const char* prop, const char* value)
@@ -174,14 +174,14 @@ void cmSourceFile::SetProperty(const char* prop, const char* value)
     {
     value = "NOTFOUND";
     }
-  m_Properties[prop] = value;
+  this->Properties[prop] = value;
 }
 
 const char *cmSourceFile::GetProperty(const char* prop) const
 {
   std::map<cmStdString,cmStdString>::const_iterator i = 
-    m_Properties.find(prop);
-  if (i != m_Properties.end())
+    this->Properties.find(prop);
+  if (i != this->Properties.end())
     {
     return i->second.c_str();
     }
@@ -191,8 +191,8 @@ const char *cmSourceFile::GetProperty(const char* prop) const
 bool cmSourceFile::GetPropertyAsBool(const char* prop) const
 {
   std::map<cmStdString,cmStdString>::const_iterator i = 
-    m_Properties.find(prop);
-  if (i != m_Properties.end())
+    this->Properties.find(prop);
+  if (i != this->Properties.end())
     {
     return cmSystemTools::IsOn(i->second.c_str());
     }
@@ -201,19 +201,19 @@ bool cmSourceFile::GetPropertyAsBool(const char* prop) const
 
 void cmSourceFile::SetCustomCommand(cmCustomCommand* cc)
 {
-  if(m_CustomCommand)
+  if(this->CustomCommand)
     {
-    delete m_CustomCommand;
+    delete this->CustomCommand;
     }
-  m_CustomCommand = cc;
+  this->CustomCommand = cc;
 }
 
 const std::string& cmSourceFile::GetSourceNameWithoutLastExtension()
 {
-  if ( m_SourceNameWithoutLastExtension.empty() )
+  if ( this->SourceNameWithoutLastExtension.empty() )
     {
-    m_SourceNameWithoutLastExtension = 
-      cmSystemTools::GetFilenameWithoutLastExtension(m_FullPath);
+    this->SourceNameWithoutLastExtension = 
+      cmSystemTools::GetFilenameWithoutLastExtension(this->FullPath);
     }
-  return m_SourceNameWithoutLastExtension;
+  return this->SourceNameWithoutLastExtension;
 }
diff --git a/Source/cmSourceFile.h b/Source/cmSourceFile.h
index c8ad1dd..656d5f0 100644
--- a/Source/cmSourceFile.h
+++ b/Source/cmSourceFile.h
@@ -34,7 +34,7 @@ public:
    */
   cmSourceFile()
     {
-      m_CustomCommand = 0;
+      this->CustomCommand = 0;
     }
   ~cmSourceFile()
     {
@@ -54,8 +54,8 @@ public:
    * Get the list of the custom commands for this source file
    */
   const cmCustomCommand *GetCustomCommand() const 
-    {return m_CustomCommand;}
-  cmCustomCommand *GetCustomCommand() {return m_CustomCommand;}
+    {return this->CustomCommand;}
+  cmCustomCommand *GetCustomCommand() {return this->CustomCommand;}
   void SetCustomCommand(cmCustomCommand *cc);
     
   /**
@@ -79,27 +79,27 @@ public:
   /**
    * The full path to the file.
    */
-  const std::string &GetFullPath() const {return m_FullPath;}
-  void SetFullPath(const char *name) {m_FullPath = name;}
+  const std::string &GetFullPath() const {return this->FullPath;}
+  void SetFullPath(const char *name) {this->FullPath = name;}
 
   /**
    * The file name associated with stripped off directory and extension.
    * (In most cases this is the name of the class.)
    */
-  const std::string &GetSourceName() const {return m_SourceName;}
-  void SetSourceName(const char *name) {m_SourceName = name;}
+  const std::string &GetSourceName() const {return this->SourceName;}
+  void SetSourceName(const char *name) {this->SourceName = name;}
 
   /**
    * The file extension associated with source file
    */
-  const std::string &GetSourceExtension() const {return m_SourceExtension;}
-  void SetSourceExtension(const char *name) {m_SourceExtension = name;}
+  const std::string &GetSourceExtension() const {return this->SourceExtension;}
+  void SetSourceExtension(const char *name) {this->SourceExtension = name;}
 
   /**
    * Return the vector that holds the list of dependencies
    */
-  const std::vector<std::string> &GetDepends() const {return m_Depends;}
-  std::vector<std::string> &GetDepends() {return m_Depends;}
+  const std::vector<std::string> &GetDepends() const {return this->Depends;}
+  std::vector<std::string> &GetDepends() {return this->Depends;}
 
   /**
    * Get the source name without last extension
@@ -107,13 +107,13 @@ public:
   const std::string& GetSourceNameWithoutLastExtension();
 
 private:
-  std::map<cmStdString,cmStdString> m_Properties;
-  cmCustomCommand *m_CustomCommand;
-  std::string m_FullPath;
-  std::string m_SourceName;
-  std::string m_SourceExtension;
-  std::vector<std::string> m_Depends;
-  std::string m_SourceNameWithoutLastExtension;
+  std::map<cmStdString,cmStdString> Properties;
+  cmCustomCommand *CustomCommand;
+  std::string FullPath;
+  std::string SourceName;
+  std::string SourceExtension;
+  std::vector<std::string> Depends;
+  std::string SourceNameWithoutLastExtension;
 };
 
 #endif
diff --git a/Source/cmSourceGroup.cxx b/Source/cmSourceGroup.cxx
index 58069d1..c34afe8 100644
--- a/Source/cmSourceGroup.cxx
+++ b/Source/cmSourceGroup.cxx
@@ -17,7 +17,7 @@
 #include "cmSourceGroup.h"
 
 //----------------------------------------------------------------------------
-cmSourceGroup::cmSourceGroup(const char* name, const char* regex): m_Name(name)
+cmSourceGroup::cmSourceGroup(const char* name, const char* regex): Name(name)
 {
   this->SetGroupRegex(regex);
 }
@@ -27,37 +27,37 @@ void cmSourceGroup::SetGroupRegex(const char* regex)
 {
   if(regex)
     {
-    m_GroupRegex.compile(regex);
+    this->GroupRegex.compile(regex);
     }
   else
     {
-    m_GroupRegex.compile("^$");
+    this->GroupRegex.compile("^$");
     }
 }
   
 //----------------------------------------------------------------------------
 void cmSourceGroup::AddGroupFile(const char* name)
 {
-  m_GroupFiles.insert(name);
+  this->GroupFiles.insert(name);
 }
   
 //----------------------------------------------------------------------------
 const char* cmSourceGroup::GetName() const
 {
-  return m_Name.c_str();
+  return this->Name.c_str();
 }
   
 //----------------------------------------------------------------------------
 bool cmSourceGroup::MatchesRegex(const char* name)
 {
-  return m_GroupRegex.find(name);
+  return this->GroupRegex.find(name);
 }
 
 //----------------------------------------------------------------------------
 bool cmSourceGroup::MatchesFiles(const char* name)
 {
-  std::set<cmStdString>::const_iterator i = m_GroupFiles.find(name);
-  if(i != m_GroupFiles.end())
+  std::set<cmStdString>::const_iterator i = this->GroupFiles.find(name);
+  if(i != this->GroupFiles.end())
     {
     return true;
     }
@@ -67,33 +67,33 @@ bool cmSourceGroup::MatchesFiles(const char* name)
 //----------------------------------------------------------------------------
 void cmSourceGroup::AssignSource(const cmSourceFile* sf)
 {
-  m_SourceFiles.push_back(sf);
+  this->SourceFiles.push_back(sf);
 }
 
 //----------------------------------------------------------------------------
 const std::vector<const cmSourceFile*>& cmSourceGroup::GetSourceFiles() const
 {
-  return m_SourceFiles;
+  return this->SourceFiles;
 }
 
 //----------------------------------------------------------------------------
 std::vector<const cmSourceFile*>& cmSourceGroup::GetSourceFiles()
 {
-  return m_SourceFiles;
+  return this->SourceFiles;
 }
 
 //----------------------------------------------------------------------------
 void cmSourceGroup::AddChild(cmSourceGroup child)
 {
-  m_GroupChildren.push_back(child);
+  this->GroupChildren.push_back(child);
 }
 
 //----------------------------------------------------------------------------
 cmSourceGroup *cmSourceGroup::lookupChild(const char* name)
 {
   // initializing iterators
-  std::vector<cmSourceGroup>::iterator iter = m_GroupChildren.begin();
-  std::vector<cmSourceGroup>::iterator end = m_GroupChildren.end();
+  std::vector<cmSourceGroup>::iterator iter = this->GroupChildren.begin();
+  std::vector<cmSourceGroup>::iterator end = this->GroupChildren.end();
 
   // st
   for(;iter!=end; ++iter)
@@ -122,8 +122,8 @@ cmSourceGroup *cmSourceGroup::lookupChild(const char* name)
 cmSourceGroup *cmSourceGroup::MatchChildrenFiles(const char *name)
 {
   // initializing iterators
-  std::vector<cmSourceGroup>::iterator iter = m_GroupChildren.begin();
-  std::vector<cmSourceGroup>::iterator end = m_GroupChildren.end();
+  std::vector<cmSourceGroup>::iterator iter = this->GroupChildren.begin();
+  std::vector<cmSourceGroup>::iterator end = this->GroupChildren.end();
 
   if(this->MatchesFiles(name))
     {
@@ -144,8 +144,8 @@ cmSourceGroup *cmSourceGroup::MatchChildrenFiles(const char *name)
 cmSourceGroup *cmSourceGroup::MatchChildrenRegex(const char *name)
 {
   // initializing iterators
-  std::vector<cmSourceGroup>::iterator iter = m_GroupChildren.begin();
-  std::vector<cmSourceGroup>::iterator end = m_GroupChildren.end();
+  std::vector<cmSourceGroup>::iterator iter = this->GroupChildren.begin();
+  std::vector<cmSourceGroup>::iterator end = this->GroupChildren.end();
 
   if(this->MatchesRegex(name))
     {
@@ -164,5 +164,5 @@ cmSourceGroup *cmSourceGroup::MatchChildrenRegex(const char *name)
 
 std::vector<cmSourceGroup> cmSourceGroup::GetGroupChildren() const
 {
-  return m_GroupChildren;
+  return this->GroupChildren;
 }
diff --git a/Source/cmSourceGroup.h b/Source/cmSourceGroup.h
index 854d174..e48fa10 100644
--- a/Source/cmSourceGroup.h
+++ b/Source/cmSourceGroup.h
@@ -102,25 +102,25 @@ private:
   /**
    * The name of the source group.
    */
-  std::string m_Name;
+  std::string Name;
   
   /**
    * The regular expression matching the files in the group.
    */
-  cmsys::RegularExpression m_GroupRegex;
+  cmsys::RegularExpression GroupRegex;
   
   /**
    * Set of file names explicitly added to this group.
    */
-  std::set<cmStdString> m_GroupFiles;
+  std::set<cmStdString> GroupFiles;
   
   /**
    * Vector of all source files that have been assigned to
    * this group.
    */
-  std::vector<const cmSourceFile*> m_SourceFiles;
+  std::vector<const cmSourceFile*> SourceFiles;
 
-  std::vector<cmSourceGroup> m_GroupChildren;
+  std::vector<cmSourceGroup> GroupChildren;
 };
 
 #endif
diff --git a/Source/cmSourceGroupCommand.cxx b/Source/cmSourceGroupCommand.cxx
index aa8ef02..67651c6 100644
--- a/Source/cmSourceGroupCommand.cxx
+++ b/Source/cmSourceGroupCommand.cxx
@@ -58,9 +58,9 @@ bool cmSourceGroupCommand::InitialPass(std::vector<std::string> const& args)
     }  
 
   std::string delimiter = "\\";
-  if(m_Makefile->GetDefinition("SOURCE_GROUP_DELIMITER"))
+  if(this->Makefile->GetDefinition("SOURCE_GROUP_DELIMITER"))
     {
-    delimiter = m_Makefile->GetDefinition("SOURCE_GROUP_DELIMITER");
+    delimiter = this->Makefile->GetDefinition("SOURCE_GROUP_DELIMITER");
     }
 
   std::vector<std::string> folders = tokenize(args[0], delimiter);
@@ -69,12 +69,12 @@ bool cmSourceGroupCommand::InitialPass(std::vector<std::string> const& args)
   cmSourceGroup* sg = NULL;
   for(unsigned int i=0;i<folders.size();++i)
     {
-    sg = m_Makefile->GetSourceGroup(folders[i].c_str());
+    sg = this->Makefile->GetSourceGroup(folders[i].c_str());
     if(!sg)
       {
-      m_Makefile->AddSourceGroup(folders[i].c_str(), 0, parent);
+      this->Makefile->AddSourceGroup(folders[i].c_str(), 0, parent);
       }
-    sg = m_Makefile->GetSourceGroup(folders[i].c_str());
+    sg = this->Makefile->GetSourceGroup(folders[i].c_str());
     parent = folders[i].c_str();
     }
   if(!sg)
@@ -120,7 +120,7 @@ bool cmSourceGroupCommand::InitialPass(std::vector<std::string> const& args)
       std::string src = args[i].c_str();
       if(!cmSystemTools::FileIsFullPath(src.c_str()))
         {
-        src = m_Makefile->GetCurrentDirectory();
+        src = this->Makefile->GetCurrentDirectory();
         src += "/";
         src += args[i];
         }
diff --git a/Source/cmStringCommand.cxx b/Source/cmStringCommand.cxx
index 4d42a05..779c6ad 100644
--- a/Source/cmStringCommand.cxx
+++ b/Source/cmStringCommand.cxx
@@ -95,7 +95,7 @@ bool cmStringCommand::HandleToUpperLowerCommand(
     }
 
   // Store the output in the provided variable.
-  m_Makefile->AddDefinition(outvar.c_str(), output.c_str());
+  this->Makefile->AddDefinition(outvar.c_str(), output.c_str());
   return true;
 }
 
@@ -127,7 +127,7 @@ bool cmStringCommand::HandleAsciiCommand(std::vector<std::string> const& args)
       }
     }
   // Store the output in the provided variable.
-  m_Makefile->AddDefinition(outvar.c_str(), output.c_str());
+  this->Makefile->AddDefinition(outvar.c_str(), output.c_str());
   return true;
 }
 
@@ -170,10 +170,10 @@ bool cmStringCommand::HandleConfigureCommand(
 
   // Configure the string.
   std::string output;
-  m_Makefile->ConfigureString(args[1], output, atOnly, escapeQuotes);
+  this->Makefile->ConfigureString(args[1], output, atOnly, escapeQuotes);
 
   // Store the output in the provided variable.
-  m_Makefile->AddDefinition(args[2].c_str(), output.c_str());
+  this->Makefile->AddDefinition(args[2].c_str(), output.c_str());
 
   return true;
 }
@@ -266,7 +266,7 @@ bool cmStringCommand::RegexMatch(std::vector<std::string> const& args)
     }
   
   // Store the output in the provided variable.
-  m_Makefile->AddDefinition(outvar.c_str(), output.c_str());
+  this->Makefile->AddDefinition(outvar.c_str(), output.c_str());
   return true;
 }
 
@@ -319,7 +319,7 @@ bool cmStringCommand::RegexMatchAll(std::vector<std::string> const& args)
     }
   
   // Store the output in the provided variable.
-  m_Makefile->AddDefinition(outvar.c_str(), output.c_str());
+  this->Makefile->AddDefinition(outvar.c_str(), output.c_str());
   return true;
 }
 
@@ -458,7 +458,7 @@ bool cmStringCommand::RegexReplace(std::vector<std::string> const& args)
   output += input.substr(base, input.length()-base);
   
   // Store the output in the provided variable.
-  m_Makefile->AddDefinition(outvar.c_str(), output.c_str());
+  this->Makefile->AddDefinition(outvar.c_str(), output.c_str());
   return true;
 }
 
@@ -506,11 +506,11 @@ bool cmStringCommand::HandleCompareCommand(std::vector<std::string> const&
       }
     if(result)
       {
-      m_Makefile->AddDefinition(outvar.c_str(), "1");
+      this->Makefile->AddDefinition(outvar.c_str(), "1");
       }
     else
       {
-      m_Makefile->AddDefinition(outvar.c_str(), "0");
+      this->Makefile->AddDefinition(outvar.c_str(), "0");
       }
     return true;
     }  
@@ -542,7 +542,7 @@ bool cmStringCommand::HandleReplaceCommand(std::vector<std::string> const&
   cmsys::SystemTools::ReplaceString(input, matchExpression.c_str(), 
                                     replaceExpression.c_str());
 
-  m_Makefile->AddDefinition(variableName.c_str(), input.c_str());
+  this->Makefile->AddDefinition(variableName.c_str(), input.c_str());
   return true;
 }
 
@@ -581,8 +581,8 @@ bool cmStringCommand::HandleSubstringCommand(std::vector<std::string> const&
     return false;
     }
 
-  m_Makefile->AddDefinition(variableName.c_str(),
-                            stringValue.substr(begin, end).c_str());
+  this->Makefile->AddDefinition(variableName.c_str(), 
+                                stringValue.substr(begin, end).c_str());
   return true;
 }
 
@@ -602,6 +602,6 @@ bool cmStringCommand::HandleLengthCommand(std::vector<std::string> const& args)
   char buffer[1024];
   sprintf(buffer, "%d", static_cast<int>(length));
 
-  m_Makefile->AddDefinition(variableName.c_str(), buffer);
+  this->Makefile->AddDefinition(variableName.c_str(), buffer);
   return true;
 }
diff --git a/Source/cmSubdirCommand.cxx b/Source/cmSubdirCommand.cxx
index ab43892..66d1829 100644
--- a/Source/cmSubdirCommand.cxx
+++ b/Source/cmSubdirCommand.cxx
@@ -43,14 +43,14 @@ bool cmSubdirCommand::InitialPass(std::vector<std::string> const& args)
       }
 
     // if they specified a relative path then compute the full
-    std::string srcPath = std::string(m_Makefile->GetCurrentDirectory()) + 
+    std::string srcPath = std::string(this->Makefile->GetCurrentDirectory()) + 
         "/" + i->c_str();
     if (cmSystemTools::FileIsDirectory(srcPath.c_str()))
       {
       std::string binPath = 
-        std::string(m_Makefile->GetCurrentOutputDirectory()) + 
+        std::string(this->Makefile->GetCurrentOutputDirectory()) + 
         "/" + i->c_str();
-      m_Makefile->AddSubDirectory(srcPath.c_str(), binPath.c_str(),
+      this->Makefile->AddSubDirectory(srcPath.c_str(), binPath.c_str(),
                                   intoplevel, preorder, false);
       }
     // otherwise it is a full path
@@ -59,9 +59,9 @@ bool cmSubdirCommand::InitialPass(std::vector<std::string> const& args)
       // we must compute the binPath from the srcPath, we just take the last
       // element from the source path and use that
       std::string binPath = 
-        std::string(m_Makefile->GetCurrentOutputDirectory()) + 
+        std::string(this->Makefile->GetCurrentOutputDirectory()) + 
         "/" + cmSystemTools::GetFilenameName(i->c_str());
-      m_Makefile->AddSubDirectory(i->c_str(), binPath.c_str(),
+      this->Makefile->AddSubDirectory(i->c_str(), binPath.c_str(),
                                   intoplevel, preorder, false);
       }
     else
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index f47122f..e698a33 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -27,29 +27,32 @@
 //----------------------------------------------------------------------------
 cmTarget::cmTarget()
 {
-  m_Makefile = 0;
-  m_LinkLibrariesAnalyzed = false;
-  m_LinkDirectoriesComputed = false;
-  m_HaveInstallRule = false;
+  this->Makefile = 0;
+  this->LinkLibrariesAnalyzed = false;
+  this->LinkDirectoriesComputed = false;
+  this->HaveInstallRule = false;
 }
 
 void cmTarget::SetType(TargetType type, const char* name)
 {
-  m_Name = name;
+  this->Name = name;
   // only add dependency information for library targets
-  m_TargetType = type;
-  if(m_TargetType >= STATIC_LIBRARY && m_TargetType <= MODULE_LIBRARY) {
-    m_RecordDependencies = true;
-  } else {
-    m_RecordDependencies = false;
-  }
+  this->TargetTypeValue = type;
+  if(this->TargetTypeValue >= STATIC_LIBRARY && this->TargetTypeValue <= MODULE_LIBRARY) 
+    {
+    this->RecordDependencies = true;
+    } 
+  else 
+    {
+    this->RecordDependencies = false;
+    }
 }
 
 //----------------------------------------------------------------------------
 void cmTarget::SetMakefile(cmMakefile* mf)
 {
   // Set our makefile.
-  m_Makefile = mf;
+  this->Makefile = mf;
 
   // Setup default property values.
   this->SetPropertyDefault("INSTALL_NAME_DIR", "");
@@ -82,7 +85,7 @@ void cmTarget::SetMakefile(cmMakefile* mf)
     // did not support this variable.  Projects may still specify the
     // property directly.  TODO: Make this depend on backwards
     // compatibility setting.
-    if(m_TargetType != cmTarget::EXECUTABLE)
+    if(this->TargetTypeValue != cmTarget::EXECUTABLE)
       {
       std::string property = cmSystemTools::UpperCase(*ci);
       property += "_POSTFIX";
@@ -227,7 +230,7 @@ void cmTarget::TraceVSDependencies(std::string projFile,
           dep = cmSystemTools::GetFilenameWithoutLastExtension(dep);
           }
         // watch for target dependencies,
-        if(m_Makefile->GetLocalGenerator()->
+        if(this->Makefile->GetLocalGenerator()->
            GetGlobalGenerator()->FindTarget(0, dep.c_str()))
           {
           // add the depend as a utility on the target
@@ -248,13 +251,13 @@ void cmTarget::TraceVSDependencies(std::string projFile,
     srcFilesToProcess.pop();
     }
   // mark all custom commands in the targets list of source files as used.
-  for(std::vector<cmSourceFile*>::iterator i =  m_SourceFiles.begin();
-      i != m_SourceFiles.end(); ++i)
+  for(std::vector<cmSourceFile*>::iterator i =  this->SourceFiles.begin();
+      i != this->SourceFiles.end(); ++i)
     {
     cmCustomCommand* cc = (*i)->GetCustomCommand();
     if(cc)
       {
-      cc->Used();
+      cc->SetUsed();
       }
     }
 }
@@ -262,15 +265,15 @@ void cmTarget::TraceVSDependencies(std::string projFile,
 void cmTarget::GenerateSourceFilesFromSourceLists( cmMakefile &mf)
 {
   // this is only done for non install targets
-  if ((this->m_TargetType == cmTarget::INSTALL_FILES)
-      || (this->m_TargetType == cmTarget::INSTALL_PROGRAMS))
+  if ((this->TargetTypeValue == cmTarget::INSTALL_FILES)
+      || (this->TargetTypeValue == cmTarget::INSTALL_PROGRAMS))
     {
     return;
     }
 
   // for each src lists add the classes
-  for (std::vector<std::string>::const_iterator s = m_SourceLists.begin();
-       s != m_SourceLists.end(); ++s)
+  for (std::vector<std::string>::const_iterator s = this->SourceLists.begin();
+       s != this->SourceLists.end(); ++s)
     {
     int done = 0;
     // replace any variables
@@ -284,7 +287,7 @@ void cmTarget::GenerateSourceFilesFromSourceLists( cmMakefile &mf)
       cmSourceFile* sourceFile = mf.GetSource(temps.c_str());
       if ( sourceFile )
         {
-        m_SourceFiles.push_back(sourceFile);
+        this->SourceFiles.push_back(sourceFile);
         done = 1;
         }
       }
@@ -297,13 +300,13 @@ void cmTarget::GenerateSourceFilesFromSourceLists( cmMakefile &mf)
       file.SetName(temps.c_str(), mf.GetCurrentDirectory(),
                    mf.GetSourceExtensions(),
                    mf.GetHeaderExtensions());
-      m_SourceFiles.push_back(mf.AddSource(file));
+      this->SourceFiles.push_back(mf.AddSource(file));
       }
     }
   
   // expand any link library variables whle we are at it
-  LinkLibraries::iterator p = m_LinkLibraries.begin();
-  for (;p != m_LinkLibraries.end(); ++p)
+  LinkLibraryVectorType::iterator p = this->LinkLibraries.begin();
+  for (;p != this->LinkLibraries.end(); ++p)
     {
     mf.ExpandVariablesInString(p->first, true, true);
     }
@@ -312,30 +315,30 @@ void cmTarget::GenerateSourceFilesFromSourceLists( cmMakefile &mf)
 
 void cmTarget::MergeLinkLibraries( cmMakefile& mf,
                                    const char *selfname,
-                                   const LinkLibraries& libs )
+                                   const LinkLibraryVectorType& libs )
 {
   // Only add on libraries we haven't added on before.
   // Assumption: the global link libraries could only grow, never shrink
-  LinkLibraries::const_iterator i = libs.begin();
-  i += m_PrevLinkedLibraries.size();
+  LinkLibraryVectorType::const_iterator i = libs.begin();
+  i += this->PrevLinkedLibraries.size();
   for( ; i != libs.end(); ++i )
     {
     // We call this so that the dependencies get written to the cache
     this->AddLinkLibrary( mf, selfname, i->first.c_str(), i->second );
     }
-  m_PrevLinkedLibraries = libs;
+  this->PrevLinkedLibraries = libs;
 }
 
 //----------------------------------------------------------------------------
 void cmTarget::AddLinkDirectory(const char* d)
 {
   // Make sure we don't add unnecessary search directories.
-  if(std::find(m_ExplicitLinkDirectories.begin(),
-               m_ExplicitLinkDirectories.end(), d)
-     == m_ExplicitLinkDirectories.end() )
+  if(std::find(this->ExplicitLinkDirectories.begin(),
+               this->ExplicitLinkDirectories.end(), d)
+     == this->ExplicitLinkDirectories.end() )
     {
-    m_ExplicitLinkDirectories.push_back( d );
-    m_LinkDirectoriesComputed = false;
+    this->ExplicitLinkDirectories.push_back( d );
+    this->LinkDirectoriesComputed = false;
     }
 }
 
@@ -343,32 +346,32 @@ void cmTarget::AddLinkDirectory(const char* d)
 const std::vector<std::string>& cmTarget::GetLinkDirectories()
 {
   // Make sure all library dependencies have been analyzed.
-  if(!m_LinkLibrariesAnalyzed && !m_LinkLibraries.empty())
+  if(!this->LinkLibrariesAnalyzed && !this->LinkLibraries.empty())
     {
     cmSystemTools::Error(
       "cmTarget::GetLinkDirectories called before "
       "cmTarget::AnalyzeLibDependencies on target ",
-      m_Name.c_str());
+      this->Name.c_str());
     }
 
   // Make sure the complete set of link directories has been computed.
-  if(!m_LinkDirectoriesComputed)
+  if(!this->LinkDirectoriesComputed)
     {
     // Compute the full set of link directories including the
     // locations of targets that have been linked in.  Start with the
     // link directories given explicitly.
-    m_LinkDirectories = m_ExplicitLinkDirectories;
-    for(LinkLibraries::iterator ll = m_LinkLibraries.begin();
-        ll != m_LinkLibraries.end(); ++ll)
+    this->LinkDirectories = this->ExplicitLinkDirectories;
+    for(LinkLibraryVectorType::iterator ll = this->LinkLibraries.begin();
+        ll != this->LinkLibraries.end(); ++ll)
       {
       // If this library is a CMake target then add its location as a
       // link directory.
       std::string lib = ll->first;
       cmTarget* tgt = 0;
-      if(m_Makefile && m_Makefile->GetLocalGenerator() &&
-         m_Makefile->GetLocalGenerator()->GetGlobalGenerator())
+      if(this->Makefile && this->Makefile->GetLocalGenerator() &&
+         this->Makefile->GetLocalGenerator()->GetGlobalGenerator())
         {
-        tgt = (m_Makefile->GetLocalGenerator()->GetGlobalGenerator()
+        tgt = (this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
                ->FindTarget(0, lib.c_str()));
         }
       if(tgt)
@@ -377,20 +380,20 @@ const std::vector<std::string>& cmTarget::GetLinkDirectories()
         // is an N^2 algorithm for adding the directories, but N
         // should not get very big.
         const char* libpath = tgt->GetDirectory();
-        if(std::find(m_LinkDirectories.begin(), m_LinkDirectories.end(),
-                     libpath) == m_LinkDirectories.end())
+        if(std::find(this->LinkDirectories.begin(), this->LinkDirectories.end(),
+                     libpath) == this->LinkDirectories.end())
           {
-          m_LinkDirectories.push_back(libpath);
+          this->LinkDirectories.push_back(libpath);
           }
         }
       }
 
     // The complete set of link directories has now been computed.
-    m_LinkDirectoriesComputed = true;
+    this->LinkDirectoriesComputed = true;
     }
 
   // Return the complete set of link directories.
-  return m_LinkDirectories;
+  return this->LinkDirectories;
 }
 
 void cmTarget::ClearDependencyInformation( cmMakefile& mf, const char* target )
@@ -399,7 +402,7 @@ void cmTarget::ClearDependencyInformation( cmMakefile& mf, const char* target )
   // recording dependency information for this target.
   std::string depname = target;
   depname += "_LIB_DEPENDS";
-  if (m_RecordDependencies)
+  if (this->RecordDependencies)
     {
     mf.AddCacheDefinition(depname.c_str(), "",
                           "Dependencies for target", cmCacheManager::STATIC);
@@ -425,8 +428,8 @@ void cmTarget::AddLinkLibrary(const std::string& lib,
                               LinkLibraryType llt)
 {
   this->AddFramework(lib.c_str(), llt);
-  m_LinkLibraries.push_back( std::pair<std::string,
-                             cmTarget::LinkLibraryType>(lib,llt) );
+  this->LinkLibraries.push_back( std::pair<std::string, 
+                                 cmTarget::LinkLibraryType>(lib,llt) );
 }
 
 bool cmTarget::AddFramework(const std::string& libname, LinkLibraryType llt)
@@ -438,11 +441,11 @@ bool cmTarget::AddFramework(const std::string& libname, LinkLibraryType llt)
     frameworkDir += "/../";
     frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir.c_str());
     std::vector<std::string>::iterator i = 
-      std::find(m_Frameworks.begin(),
-                m_Frameworks.end(), frameworkDir);
-    if(i == m_Frameworks.end())
+      std::find(this->Frameworks.begin(),
+                this->Frameworks.end(), frameworkDir);
+    if(i == this->Frameworks.end())
       {
-      m_Frameworks.push_back(frameworkDir);
+      this->Frameworks.push_back(frameworkDir);
       }
     return true;
     }
@@ -458,8 +461,8 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf,
     return;
     }
   this->AddFramework(lib, llt);
-  m_LinkLibraries.push_back( std::pair<std::string,
-                             cmTarget::LinkLibraryType>(lib,llt) );
+  this->LinkLibraries.push_back( std::pair<std::string, 
+                                 cmTarget::LinkLibraryType>(lib,llt) );
 
   if(llt != cmTarget::GENERAL)
     {
@@ -483,11 +486,10 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf,
           }
         else
           {
-          mf.AddCacheDefinition(linkTypeName.c_str(),
-                                "general", 
-                                "Library is used for both debug "
-                                "and optimized links",
-                                cmCacheManager::STATIC);
+          mf.AddCacheDefinition
+            (linkTypeName.c_str(), "general", 
+             "Library is used for both debug and optimized links",
+             cmCacheManager::STATIC);
           }
         }
         break;
@@ -496,17 +498,17 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf,
         const char* def = mf.GetDefinition(linkTypeName.c_str());
         if(!def || strcmp(def, "optimized") == 0)
           {
-          mf.AddCacheDefinition(linkTypeName.c_str(),
-                                "optimized", "Library is used for debug "
-                                "links only",
-                                cmCacheManager::STATIC);
+          mf.AddCacheDefinition
+            (linkTypeName.c_str(), "optimized", 
+             "Library is used for debug links only",
+             cmCacheManager::STATIC);
           }
         else
           {
-          mf.AddCacheDefinition(linkTypeName.c_str(),
-                                "general", "Library is used for both debug "
-                                "and optimized links",
-                                cmCacheManager::STATIC);
+          mf.AddCacheDefinition
+            (linkTypeName.c_str(), "general", 
+             "Library is used for both debug and optimized links",
+             cmCacheManager::STATIC);
           }
         }
         break;
@@ -522,7 +524,7 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf,
   // may be purposefully duplicated to handle recursive dependencies,
   // and we removing one instance will break the link line. Duplicates
   // will be appropriately eliminated at emit time.
-  if(m_RecordDependencies)
+  if(this->RecordDependencies)
     {
     std::string targetEntry = target;
     targetEntry += "_LIB_DEPENDS";
@@ -618,15 +620,15 @@ cmTarget::AnalyzeLibDependencies( const cmMakefile& mf )
   // The dependency map.
   DependencyMap dep_map;
 
-  if ( m_OriginalLinkLibraries.size() == 0 )
+  if ( this->OriginalLinkLibraries.size() == 0 )
     {
-    m_OriginalLinkLibraries = m_LinkLibraries;
+    this->OriginalLinkLibraries = this->LinkLibraries;
     }
 
   // 1. Build the dependency graph
   //
-  for(LinkLibraries::reverse_iterator lib = m_LinkLibraries.rbegin();
-      lib != m_LinkLibraries.rend(); ++lib)
+  for(LinkLibraryVectorType::reverse_iterator lib = this->LinkLibraries.rbegin();
+      lib != this->LinkLibraries.rend(); ++lib)
     {
     this->GatherDependencies( mf, lib->first, dep_map );
     }
@@ -634,11 +636,11 @@ cmTarget::AnalyzeLibDependencies( const cmMakefile& mf )
   // 2. Remove any dependencies that are already satisfied in the original
   // link line.
   //
-  for(LinkLibraries::iterator lib = m_LinkLibraries.begin();
-      lib != m_LinkLibraries.end(); ++lib)
+  for(LinkLibraryVectorType::iterator lib = this->LinkLibraries.begin();
+      lib != this->LinkLibraries.end(); ++lib)
     {
-    for( LinkLibraries::iterator lib2 = lib;
-      lib2 != m_LinkLibraries.end(); ++lib2)
+    for( LinkLibraryVectorType::iterator lib2 = lib;
+      lib2 != this->LinkLibraries.end(); ++lib2)
       {
       DeleteDependency( dep_map, lib->first, lib2->first );
       }
@@ -650,8 +652,9 @@ cmTarget::AnalyzeLibDependencies( const cmMakefile& mf )
   //
   std::set<cmStdString> done, visited;
   std::vector<std::string> newLinkLibraries;
-  for(LinkLibraries::reverse_iterator lib = m_LinkLibraries.rbegin();
-      lib != m_LinkLibraries.rend(); ++lib)
+  for(LinkLibraryVectorType::reverse_iterator lib = 
+        this->LinkLibraries.rbegin();
+      lib != this->LinkLibraries.rend(); ++lib)
     {
     // skip zero size library entries, this may happen
     // if a variable expands to nothing.
@@ -682,9 +685,9 @@ cmTarget::AnalyzeLibDependencies( const cmMakefile& mf )
         llt = cmTarget::OPTIMIZED;
         }
       }
-    m_LinkLibraries.push_back( std::make_pair(*k,llt) );
+    this->LinkLibraries.push_back( std::make_pair(*k,llt) );
     }
-  m_LinkLibrariesAnalyzed = true;
+  this->LinkLibrariesAnalyzed = true;
 }
 
 
@@ -825,7 +828,7 @@ void cmTarget::SetProperty(const char* prop, const char* value)
     {
     value = "NOTFOUND";
     }
-  m_Properties[prop] = value;
+  this->Properties[prop] = value;
 }
 
 const char* cmTarget::GetDirectory(const char* config)
@@ -835,42 +838,43 @@ const char* cmTarget::GetDirectory(const char* config)
     case cmTarget::STATIC_LIBRARY:
     case cmTarget::MODULE_LIBRARY:
     case cmTarget::SHARED_LIBRARY:
-      m_Directory = m_Makefile->GetSafeDefinition("LIBRARY_OUTPUT_PATH");
+      this->Directory = this->Makefile->GetSafeDefinition("LIBRARY_OUTPUT_PATH");
       break;
     case cmTarget::EXECUTABLE:
-      m_Directory = m_Makefile->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
+      this->Directory = this->Makefile->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
       break;
     default:
       return 0;
     }
-  if(m_Directory.empty())
+  if(this->Directory.empty())
     {
-    m_Directory = m_Makefile->GetStartOutputDirectory();
+    this->Directory = this->Makefile->GetStartOutputDirectory();
     }
+
   if(config)
     {
     // Add the configuration's subdirectory.
-    m_Makefile->GetLocalGenerator()->GetGlobalGenerator()->
-      AppendDirectoryForConfig("/", config, "", m_Directory);
+    this->Makefile->GetLocalGenerator()->GetGlobalGenerator()->
+      AppendDirectoryForConfig("/", config, "", this->Directory);
     }
-  return m_Directory.c_str();
+  return this->Directory.c_str();
 }
 
 const char* cmTarget::GetLocation(const char* config)
 {
-  m_Location = this->GetDirectory();
-  if(!m_Location.empty())
+  this->Location = this->GetDirectory();
+  if(!this->Location.empty())
     {
-    m_Location += "/";
+    this->Location += "/";
     }
-  const char* cfgid = m_Makefile->GetDefinition("CMAKE_CFG_INTDIR");
+  const char* cfgid = this->Makefile->GetDefinition("CMAKE_CFG_INTDIR");
   if(cfgid && strcmp(cfgid, ".") != 0)
     {
-    m_Location += cfgid;
-    m_Location += "/";
+    this->Location += cfgid;
+    this->Location += "/";
     }
-  m_Location += this->GetFullName(config, false);
-  return m_Location.c_str();
+  this->Location += this->GetFullName(config, false);
+  return this->Location.c_str();
 }
 
 const char *cmTarget::GetProperty(const char* prop)
@@ -925,8 +929,8 @@ const char *cmTarget::GetProperty(const char* prop)
     }
       
   std::map<cmStdString,cmStdString>::const_iterator i = 
-    m_Properties.find(prop);
-  if (i != m_Properties.end())
+    this->Properties.find(prop);
+  if (i != this->Properties.end())
     {
     return i->second.c_str();
     }
@@ -936,8 +940,8 @@ const char *cmTarget::GetProperty(const char* prop)
 bool cmTarget::GetPropertyAsBool(const char* prop)
 {
   std::map<cmStdString,cmStdString>::const_iterator i = 
-    m_Properties.find(prop);
-  if (i != m_Properties.end())
+    this->Properties.find(prop);
+  if (i != this->Properties.end())
     {
     return cmSystemTools::IsOn(i->second.c_str());
     }
@@ -956,8 +960,8 @@ const char* cmTarget::GetLinkerLanguage(cmGlobalGenerator* gg)
     return linkerLang;
     }
   std::set<cmStdString> languages;
-  for(std::vector<cmSourceFile*>::const_iterator i = m_SourceFiles.begin();
-      i != m_SourceFiles.end(); ++i)
+  for(std::vector<cmSourceFile*>::const_iterator i = this->SourceFiles.begin();
+      i != this->SourceFiles.end(); ++i)
     {
     const char* lang = 
       gg->GetLanguageFromExtension((*i)->GetSourceExtension().c_str());
@@ -986,7 +990,7 @@ const char* cmTarget::GetLinkerLanguage(cmGlobalGenerator* gg)
       if(prefLang && !(*s == prefLang))
         {
         std::string m = "Error Target: ";
-        m += m_Name + " Contains more than one Prefered language: ";
+        m += this->Name + " Contains more than one Prefered language: ";
         m += *s;
         m += " and ";
         m += prefLang;
@@ -1158,31 +1162,31 @@ void cmTarget::GetFullNameInternal(TargetType type,
   const char* suffixVar = this->GetSuffixVariableInternal(type, implib);
   const char* ll =
     this->GetLinkerLanguage(
-      m_Makefile->GetLocalGenerator()->GetGlobalGenerator());
+      this->Makefile->GetLocalGenerator()->GetGlobalGenerator());
   // first try language specific suffix
   if(ll)
     {
     if(!targetSuffix && suffixVar && *suffixVar)
       {
       std::string langSuff = suffixVar + std::string("_") + ll;
-      targetSuffix = m_Makefile->GetDefinition(langSuff.c_str());
+      targetSuffix = this->Makefile->GetDefinition(langSuff.c_str());
       }
     if(!targetPrefix && prefixVar && *prefixVar)
       {
       std::string langPrefix = prefixVar + std::string("_") + ll;
-      targetPrefix = m_Makefile->GetDefinition(langPrefix.c_str());
+      targetPrefix = this->Makefile->GetDefinition(langPrefix.c_str());
       }
     }
 
   // if there is no prefix on the target use the cmake definition
   if(!targetPrefix && prefixVar)
     {
-    targetPrefix = m_Makefile->GetSafeDefinition(prefixVar);
+    targetPrefix = this->Makefile->GetSafeDefinition(prefixVar);
     }
   // if there is no suffix on the target use the cmake definition
   if(!targetSuffix && suffixVar)
     {
-    targetSuffix = m_Makefile->GetSafeDefinition(suffixVar);
+    targetSuffix = this->Makefile->GetSafeDefinition(suffixVar);
     }
 
   // Begin the final name with the prefix.
@@ -1260,7 +1264,7 @@ void cmTarget::GetLibraryNamesInternal(std::string& name,
   // Construct the name of the soname flag variable for this language.
   const char* ll =
     this->GetLinkerLanguage(
-      m_Makefile->GetLocalGenerator()->GetGlobalGenerator());
+      this->Makefile->GetLocalGenerator()->GetGlobalGenerator());
   std::string sonameFlag = "CMAKE_SHARED_LIBRARY_SONAME";
   if(ll)
     {
@@ -1273,7 +1277,7 @@ void cmTarget::GetLibraryNamesInternal(std::string& name,
   const char* version = this->GetProperty("VERSION");
   const char* soversion = this->GetProperty("SOVERSION");
   if((type != cmTarget::SHARED_LIBRARY && type != cmTarget::MODULE_LIBRARY) ||
-     !m_Makefile->GetDefinition(sonameFlag.c_str()))
+     !this->Makefile->GetDefinition(sonameFlag.c_str()))
     {
     // Versioning is supported only for shared libraries and modules,
     // and then only when the platform supports an soname flag.
@@ -1377,7 +1381,7 @@ void cmTarget::SetPropertyDefault(const char* property,
   std::string var = "CMAKE_";
   var += property;
 
-  if(const char* value = m_Makefile->GetDefinition(var.c_str()))
+  if(const char* value = this->Makefile->GetDefinition(var.c_str()))
     {
     this->SetProperty(property, value);
     }
@@ -1391,7 +1395,7 @@ void cmTarget::SetPropertyDefault(const char* property,
 bool cmTarget::HaveBuildTreeRPATH()
 {
   return (!this->GetPropertyAsBool("SKIP_BUILD_RPATH") &&
-          !m_LinkLibraries.empty());
+          !this->LinkLibraries.empty());
 }
 
 //----------------------------------------------------------------------------
@@ -1406,9 +1410,9 @@ bool cmTarget::NeedRelinkBeforeInstall()
 {
   // Only executables and shared libraries can have an rpath and may
   // need relinking.
-  if(m_TargetType != cmTarget::EXECUTABLE &&
-     m_TargetType != cmTarget::SHARED_LIBRARY &&
-     m_TargetType != cmTarget::MODULE_LIBRARY)
+  if(this->TargetTypeValue != cmTarget::EXECUTABLE &&
+     this->TargetTypeValue != cmTarget::SHARED_LIBRARY &&
+     this->TargetTypeValue != cmTarget::MODULE_LIBRARY)
     {
     return false;
     }
@@ -1421,7 +1425,7 @@ bool cmTarget::NeedRelinkBeforeInstall()
     }
 
   // If skipping all rpaths completely then no relinking is needed.
-  if(m_Makefile->IsOn("CMAKE_SKIP_RPATH"))
+  if(this->Makefile->IsOn("CMAKE_SKIP_RPATH"))
     {
     return false;
     }
@@ -1434,12 +1438,12 @@ bool cmTarget::NeedRelinkBeforeInstall()
 
   // Check for rpath support on this platform.
   if(const char* ll = this->GetLinkerLanguage(
-       m_Makefile->GetLocalGenerator()->GetGlobalGenerator()))
+       this->Makefile->GetLocalGenerator()->GetGlobalGenerator()))
     {
     std::string flagVar = "CMAKE_SHARED_LIBRARY_RUNTIME_";
     flagVar += ll;
     flagVar += "_FLAG";
-    if(!m_Makefile->IsSet(flagVar.c_str()))
+    if(!this->Makefile->IsSet(flagVar.c_str()))
       {
       // There is no rpath support on this platform so nothing needs
       // relinking.
@@ -1470,8 +1474,8 @@ std::string cmTarget::GetInstallNameDirForBuildTree(const char* config)
     }
 
   // Use the build tree directory for the target.
-  if(m_Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME") &&
-     !m_Makefile->IsOn("CMAKE_SKIP_RPATH") &&
+  if(this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME") &&
+     !this->Makefile->IsOn("CMAKE_SKIP_RPATH") &&
      !this->GetPropertyAsBool("SKIP_BUILD_RPATH"))
     {
     std::string dir = this->GetDirectory(config);
@@ -1489,8 +1493,8 @@ std::string cmTarget::GetInstallNameDirForInstallTree(const char*)
 {
   // Lookup the target property.
   const char* install_name_dir = this->GetProperty("INSTALL_NAME_DIR");
-  if(m_Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME") &&
-     !m_Makefile->IsOn("CMAKE_SKIP_RPATH") &&
+  if(this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME") &&
+     !this->Makefile->IsOn("CMAKE_SKIP_RPATH") &&
      install_name_dir && *install_name_dir)
     {
     std::string dir = install_name_dir;
diff --git a/Source/cmTarget.h b/Source/cmTarget.h
index fce361d..6ad4770 100644
--- a/Source/cmTarget.h
+++ b/Source/cmTarget.h
@@ -44,7 +44,7 @@ public:
    */
   TargetType GetType()
     {
-      return m_TargetType;
+      return this->TargetTypeValue;
     }
   
   /**
@@ -53,7 +53,7 @@ public:
   void SetType(TargetType f, const char* name);
 
   ///! Set/Get the name of the target
-  const char* GetName() {return m_Name.c_str();}
+  const char* GetName() {return this->Name.c_str();}
 
   /**
    * Indicate whether the target is part of the all target
@@ -64,40 +64,42 @@ public:
 
   ///! Set the cmMakefile that owns this target
   void SetMakefile(cmMakefile *mf);
-  cmMakefile *GetMakefile() { return m_Makefile;};
+  cmMakefile *GetMakefile() { return this->Makefile;};
   
   /**
    * Get the list of the custom commands for this target
    */
   std::vector<cmCustomCommand> &GetPreBuildCommands() 
-    {return m_PreBuildCommands;}
+    {return this->PreBuildCommands;}
   std::vector<cmCustomCommand> &GetPreLinkCommands() 
-    {return m_PreLinkCommands;}
+    {return this->PreLinkCommands;}
   std::vector<cmCustomCommand> &GetPostBuildCommands() 
-    {return m_PostBuildCommands;}
+    {return this->PostBuildCommands;}
 
   /**
    * Get the list of the source lists used by this target
    */
-  std::vector<std::string> &GetSourceLists() {return m_SourceLists;}
+  std::vector<std::string> &GetSourceLists() {return this->SourceLists;}
 
   ///! Return the list of frameworks being linked to this target
-  std::vector<std::string> &GetFrameworks() {return m_Frameworks;}
+  std::vector<std::string> &GetFrameworks() {return this->Frameworks;}
   
   /**
    * Get the list of the source files used by this target
    */
-  std::vector<cmSourceFile*> &GetSourceFiles() {return m_SourceFiles;}
+  std::vector<cmSourceFile*> &GetSourceFiles() {return this->SourceFiles;}
 
   /**
    * Get the list of the source files used by this target
    */
   enum LinkLibraryType {GENERAL, DEBUG, OPTIMIZED};
-  typedef std::vector<std::pair<std::string,LinkLibraryType> > LinkLibraries;
-  const LinkLibraries &GetLinkLibraries() {return m_LinkLibraries;}
-  const LinkLibraries &GetOriginalLinkLibraries() 
-    {return m_OriginalLinkLibraries;}
 
+  typedef std::vector<std::pair<std::string,LinkLibraryType> > 
+  LinkLibraryVectorType;
+  const LinkLibraryVectorType &GetLinkLibraries() {return this->LinkLibraries;}
+  const LinkLibraryVectorType &GetOriginalLinkLibraries() 
+    {return this->OriginalLinkLibraries;}
+  
   /**
    * Clear the dependency information recorded for this target, if any.
    */
@@ -112,8 +114,8 @@ public:
   void AddLinkLibrary(const std::string& lib, 
                       LinkLibraryType llt);
 
-  void MergeLinkLibraries( cmMakefile& mf, const char* selfname,
-                           const LinkLibraries& libs );
+  void MergeLinkLibraries( cmMakefile& mf, const char* selfname, 
+                           const LinkLibraryVectorType& libs );
 
   const std::vector<std::string>& GetLinkDirectories();
 
@@ -123,21 +125,21 @@ public:
    * Set the path where this target should be installed. This is relative to
    * INSTALL_PREFIX
    */
-  std::string GetInstallPath() {return m_InstallPath;}
-  void SetInstallPath(const char *name) {m_InstallPath = name;}
+  std::string GetInstallPath() {return this->InstallPath;}
+  void SetInstallPath(const char *name) {this->InstallPath = name;}
   
   /**
    * Set the path where this target (if it has a runtime part) should be
    * installed. This is relative to INSTALL_PREFIX
    */
-  std::string GetRuntimeInstallPath() {return m_RuntimeInstallPath;}
-  void SetRuntimeInstallPath(const char *name) {m_RuntimeInstallPath = name;}
+  std::string GetRuntimeInstallPath() {return this->RuntimeInstallPath;}
+  void SetRuntimeInstallPath(const char *name) {this->RuntimeInstallPath = name;}
 
   /**
    * Get/Set whether there is an install rule for this target.
    */
-  bool GetHaveInstallRule() { return m_HaveInstallRule; }
-  void SetHaveInstallRule(bool h) { m_HaveInstallRule = h; }
+  bool GetHaveInstallRule() { return this->HaveInstallRule; }
+  void SetHaveInstallRule(bool h) { this->HaveInstallRule = h; }
 
   /**
    * Generate the SourceFilesList from the SourceLists. This should only be
@@ -149,9 +151,9 @@ public:
    * name as would be specified to the ADD_EXECUTABLE or UTILITY_SOURCE
    * commands. It is not a full path nor does it have an extension.  
    */
-  void AddUtility(const char* u) { m_Utilities.insert(u);}
+  void AddUtility(const char* u) { this->Utilities.insert(u);}
   ///! Get the utilities used by this target
-  std::set<cmStdString>const& GetUtilities() { return m_Utilities; }
+  std::set<cmStdString>const& GetUtilities() { return this->Utilities; }
 
   void AnalyzeLibDependencies( const cmMakefile& mf );
 
@@ -313,33 +315,33 @@ private:
   // If the variable is not defined use the given default instead.
   void SetPropertyDefault(const char* property, const char* default_value);
 private:
-  std::string m_Name;
-  std::vector<cmCustomCommand> m_PreBuildCommands;
-  std::vector<cmCustomCommand> m_PreLinkCommands;
-  std::vector<cmCustomCommand> m_PostBuildCommands;
-  std::vector<std::string> m_SourceLists;
-  TargetType m_TargetType;
-  std::vector<cmSourceFile*> m_SourceFiles;
-  LinkLibraries m_LinkLibraries;
-  LinkLibraries m_PrevLinkedLibraries;
-  LinkLibraries m_OriginalLinkLibraries;
-  bool m_LinkLibrariesAnalyzed;
-  bool m_LinkDirectoriesComputed;
-  std::vector<std::string> m_Frameworks;
-  std::vector<std::string> m_LinkDirectories;
-  std::vector<std::string> m_ExplicitLinkDirectories;
-  bool m_HaveInstallRule;
-  std::string m_InstallPath;
-  std::string m_RuntimeInstallPath;
-  std::string m_Directory;
-  std::string m_Location;
-  std::set<cmStdString> m_Utilities;
-  bool m_RecordDependencies; 
-  std::map<cmStdString,cmStdString> m_Properties;
+  std::string Name;
+  std::vector<cmCustomCommand> PreBuildCommands;
+  std::vector<cmCustomCommand> PreLinkCommands;
+  std::vector<cmCustomCommand> PostBuildCommands;
+  std::vector<std::string> SourceLists;
+  TargetType TargetTypeValue;
+  std::vector<cmSourceFile*> SourceFiles;
+  LinkLibraryVectorType LinkLibraries;
+  LinkLibraryVectorType PrevLinkedLibraries;
+  bool LinkLibrariesAnalyzed;
+  bool LinkDirectoriesComputed;
+  std::vector<std::string> Frameworks;
+  std::vector<std::string> LinkDirectories;
+  std::vector<std::string> ExplicitLinkDirectories;
+  bool HaveInstallRule;
+  std::string InstallPath;
+  std::string RuntimeInstallPath;
+  std::string Directory;
+  std::string Location;
+  std::set<cmStdString> Utilities;
+  bool RecordDependencies; 
+  std::map<cmStdString,cmStdString> Properties;
+  LinkLibraryVectorType OriginalLinkLibraries;
 
   // The cmMakefile instance that owns this target.  This should
   // always be set.
-  cmMakefile* m_Makefile;
+  cmMakefile* Makefile;
 };
 
 typedef std::map<cmStdString,cmTarget> cmTargets;
diff --git a/Source/cmTargetLinkLibrariesCommand.cxx b/Source/cmTargetLinkLibrariesCommand.cxx
index 71d649f..4753bd8 100644
--- a/Source/cmTargetLinkLibrariesCommand.cxx
+++ b/Source/cmTargetLinkLibrariesCommand.cxx
@@ -27,8 +27,6 @@ bool cmTargetLinkLibrariesCommand::InitialPass(std::vector<std::string>
     return false;
     }
 
-  m_TargetName = args[0];
-
   // but we might not have any libs after variable expansion
   if(args.size() < 2)
     {
@@ -48,7 +46,7 @@ bool cmTargetLinkLibrariesCommand::InitialPass(std::vector<std::string>
         this->SetError("The \"debug\" argument must be followed by a library");
         return false;
         }
-      m_Makefile->AddLinkLibraryForTarget(args[0].c_str(),i->c_str(),
+      this->Makefile->AddLinkLibraryForTarget(args[0].c_str(),i->c_str(),
                                           cmTarget::DEBUG);
       }
     else if (*i == "optimized")
@@ -60,12 +58,12 @@ bool cmTargetLinkLibrariesCommand::InitialPass(std::vector<std::string>
           "The \"optimized\" argument must be followed by a library");
         return false;
         }
-      m_Makefile->AddLinkLibraryForTarget(args[0].c_str(),i->c_str(),
+      this->Makefile->AddLinkLibraryForTarget(args[0].c_str(),i->c_str(),
                                  cmTarget::OPTIMIZED);
       }
     else
       {
-      m_Makefile->AddLinkLibraryForTarget(args[0].c_str(),i->c_str(),
+      this->Makefile->AddLinkLibraryForTarget(args[0].c_str(),i->c_str(),
                                           cmTarget::GENERAL);  
       }
     } 
diff --git a/Source/cmTargetLinkLibrariesCommand.h b/Source/cmTargetLinkLibrariesCommand.h
index 2e1b0d4..8191ec8 100644
--- a/Source/cmTargetLinkLibrariesCommand.h
+++ b/Source/cmTargetLinkLibrariesCommand.h
@@ -74,7 +74,6 @@ public:
   
   cmTypeMacro(cmTargetLinkLibrariesCommand, cmCommand);
 private:
-  std::string m_TargetName;
 };
 
 
diff --git a/Source/cmTest.cxx b/Source/cmTest.cxx
index ccef841..affff8a 100644
--- a/Source/cmTest.cxx
+++ b/Source/cmTest.cxx
@@ -32,7 +32,7 @@ void cmTest::SetName(const char* name)
     {
     name = "";
     }
-  m_Name = name;
+  this->Name = name;
 }
 
 void cmTest::SetCommand(const char* command)
@@ -41,19 +41,19 @@ void cmTest::SetCommand(const char* command)
     {
     command = "";
     }
-  m_Command = command;
+  this->Command = command;
 }
 
 void cmTest::SetArguments(const std::vector<cmStdString>& args)
 {
-  m_Args = args;
+  this->Args = args;
 }
 
 const char *cmTest::GetProperty(const char* prop) const
 {
   std::map<cmStdString,cmStdString>::const_iterator i = 
-    m_Properties.find(prop);
-  if (i != m_Properties.end())
+    this->Properties.find(prop);
+  if (i != this->Properties.end())
     {
     return i->second.c_str();
     }
@@ -63,8 +63,8 @@ const char *cmTest::GetProperty(const char* prop) const
 bool cmTest::GetPropertyAsBool(const char* prop) const
 {
   std::map<cmStdString,cmStdString>::const_iterator i = 
-    m_Properties.find(prop);
-  if (i != m_Properties.end())
+    this->Properties.find(prop);
+  if (i != this->Properties.end())
     {
     return cmSystemTools::IsOn(i->second.c_str());
     }
@@ -81,6 +81,6 @@ void cmTest::SetProperty(const char* prop, const char* value)
     {
     value = "NOTFOUND";
     }
-  m_Properties[prop] = value;
+  this->Properties[prop] = value;
 }
 
diff --git a/Source/cmTest.h b/Source/cmTest.h
index ac1087f..2f12835 100644
--- a/Source/cmTest.h
+++ b/Source/cmTest.h
@@ -34,13 +34,13 @@ public:
 
   ///! Set the test name
   void SetName(const char* name);
-  const char* GetName() const { return m_Name.c_str(); }
+  const char* GetName() const { return this->Name.c_str(); }
   void SetCommand(const char* command);
-  const char* GetCommand() const { return m_Command.c_str(); }
+  const char* GetCommand() const { return this->Command.c_str(); }
   void SetArguments(const std::vector<cmStdString>& args);
   const std::vector<cmStdString>& GetArguments() const
     {
-    return m_Args;
+    return this->Args;
     }
 
   /**
@@ -54,14 +54,14 @@ public:
   bool GetPropertyAsBool(const char *prop) const;
   const std::map<cmStdString,cmStdString>& GetProperties() const
     {
-    return m_Properties;
+    return this->Properties;
     }
     
 private:
-  std::map<cmStdString,cmStdString> m_Properties;
-  cmStdString m_Name;
-  cmStdString m_Command;
-  std::vector<cmStdString> m_Args;
+  std::map<cmStdString,cmStdString> Properties;
+  cmStdString Name;
+  cmStdString Command;
+  std::vector<cmStdString> Args;
 };
 
 #endif
diff --git a/Source/cmTryCompileCommand.cxx b/Source/cmTryCompileCommand.cxx
index bbf74fc..86353d2 100644
--- a/Source/cmTryCompileCommand.cxx
+++ b/Source/cmTryCompileCommand.cxx
@@ -266,7 +266,7 @@ bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv)
     return false;
     }
 
-  cmTryCompileCommand::CoreTryCompileCode(m_Makefile,argv,true);
+  cmTryCompileCommand::CoreTryCompileCode(this->Makefile,argv,true);
   
   return true;
 }
diff --git a/Source/cmTryRunCommand.cxx b/Source/cmTryRunCommand.cxx
index a0f28aa..ba7b481 100644
--- a/Source/cmTryRunCommand.cxx
+++ b/Source/cmTryRunCommand.cxx
@@ -64,8 +64,8 @@ bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv)
       }
     }
   // do the try compile
-  int res = cmTryCompileCommand::CoreTryCompileCode(m_Makefile, tryCompile,
-                                                    false);
+  int res = cmTryCompileCommand::CoreTryCompileCode(this->Makefile, 
+                                                    tryCompile, false);
   
   // now try running the command if it compiled
   std::string binaryDirectory = argv[2] + "/CMakeFiles/CMakeTmp";
@@ -127,12 +127,12 @@ bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv)
         // if the TryCompileCore saved output in this outputVariable then
         // prepend that output to this output
         const char* compileOutput
-          = m_Makefile->GetDefinition(outputVariable.c_str());
+          = this->Makefile->GetDefinition(outputVariable.c_str());
         if(compileOutput)
           {
           output = std::string(compileOutput) + output;
           }
-        m_Makefile->AddDefinition(outputVariable.c_str(), output.c_str());
+        this->Makefile->AddDefinition(outputVariable.c_str(), output.c_str());
         }
       // set the run var
       char retChar[1000];
@@ -144,7 +144,7 @@ bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv)
         {
         strcpy(retChar, "FAILED_TO_RUN");
         }
-      m_Makefile->AddCacheDefinition(argv[0].c_str(), retChar,
+      this->Makefile->AddCacheDefinition(argv[0].c_str(), retChar,
                                      "Result of TRY_RUN",
                                      cmCacheManager::INTERNAL);
       }
@@ -153,7 +153,7 @@ bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv)
   // if we created a directory etc, then cleanup after ourselves  
   std::string cacheFile = binaryDirectory;
   cacheFile += "/CMakeLists.txt";
-  if(!m_Makefile->GetCMakeInstance()->GetDebugTryCompile())
+  if(!this->Makefile->GetCMakeInstance()->GetDebugTryCompile())
     {
     cmTryCompileCommand::CleanupFiles(binaryDirectory.c_str());
     }
diff --git a/Source/cmUtilitySourceCommand.cxx b/Source/cmUtilitySourceCommand.cxx
index a5f7f53..0bb0c1d 100644
--- a/Source/cmUtilitySourceCommand.cxx
+++ b/Source/cmUtilitySourceCommand.cxx
@@ -30,16 +30,16 @@ bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args)
   // The first argument is the cache entry name.
   std::string cacheEntry = *arg++;
   const char* cacheValue =
-    m_Makefile->GetDefinition(cacheEntry.c_str());
+    this->Makefile->GetDefinition(cacheEntry.c_str());
   // If it exists already and appears up to date then we are done.  If
   // the string contains "(IntDir)" but that is not the
   // CMAKE_CFG_INTDIR setting then the value is out of date.
-  const char* intDir = m_Makefile->GetRequiredDefinition("CMAKE_CFG_INTDIR");
+  const char* intDir = this->Makefile->GetRequiredDefinition("CMAKE_CFG_INTDIR");
   if(cacheValue &&
      (strstr(cacheValue, "(IntDir)") == 0 ||
       intDir && strcmp(intDir, "$(IntDir)") == 0) &&
-     (m_Makefile->GetCacheMajorVersion() != 0 &&
-      m_Makefile->GetCacheMinorVersion() != 0 ))
+     (this->Makefile->GetCacheMajorVersion() != 0 &&
+      this->Makefile->GetCacheMinorVersion() != 0 ))
     {
     return true;
     }
@@ -51,7 +51,7 @@ bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args)
   // The third argument specifies the relative directory of the source
   // of the utility.
   std::string relativeSource = *arg++;
-  std::string utilitySource = m_Makefile->GetCurrentDirectory();
+  std::string utilitySource = this->Makefile->GetCurrentDirectory();
   utilitySource = utilitySource+"/"+relativeSource;
   
   // If the directory doesn't exist, the source has not been included.
@@ -67,13 +67,13 @@ bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args)
     }
   
   // The source exists.
-  std::string cmakeCFGout =
-    m_Makefile->GetRequiredDefinition("CMAKE_CFG_INTDIR");
-  std::string utilityDirectory = m_Makefile->GetCurrentOutputDirectory();
+  std::string cmakeCFGout = 
+    this->Makefile->GetRequiredDefinition("CMAKE_CFG_INTDIR");
+  std::string utilityDirectory = this->Makefile->GetCurrentOutputDirectory();
   std::string exePath;
-  if (m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
+  if (this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
     {
-    exePath = m_Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH");
+    exePath = this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH");
     }
   if(exePath.size())
     {
@@ -93,14 +93,14 @@ bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args)
   cmSystemTools::ReplaceString(utilityExecutable, "/./", "/");
   
   // Enter the value into the cache.
-  m_Makefile->AddCacheDefinition(cacheEntry.c_str(),
+  this->Makefile->AddCacheDefinition(cacheEntry.c_str(),
                                  utilityExecutable.c_str(),
                                  "Path to an internal program.",
                                  cmCacheManager::FILEPATH);
   // add a value into the cache that maps from the
   // full path to the name of the project
   cmSystemTools::ConvertToUnixSlashes(utilityExecutable);
-  m_Makefile->AddCacheDefinition(utilityExecutable.c_str(),
+  this->Makefile->AddCacheDefinition(utilityExecutable.c_str(),
                                  utilityName.c_str(),
                                  "Executable to project name.",
                                  cmCacheManager::INTERNAL);
diff --git a/Source/cmVTKMakeInstantiatorCommand.cxx b/Source/cmVTKMakeInstantiatorCommand.cxx
index 4b7955e..acccd2b 100644
--- a/Source/cmVTKMakeInstantiatorCommand.cxx
+++ b/Source/cmVTKMakeInstantiatorCommand.cxx
@@ -30,22 +30,22 @@ cmVTKMakeInstantiatorCommand
     return false;
     }
   std::vector<std::string> args;
-  m_Makefile->ExpandSourceListArguments(argsIn, args, 2);
+  this->Makefile->ExpandSourceListArguments(argsIn, args, 2);
   std::string sourceListValue;
   
-  m_ClassName = args[0];
+  this->ClassName = args[0];
   
   std::vector<cmStdString> inSourceLists;
-  m_ExportMacro = "-";
+  this->ExportMacro = "-";
   bool includesMode = false;
   bool oldVersion = true;
   
   // Find the path of the files to be generated.
-  std::string filePath = m_Makefile->GetCurrentOutputDirectory();
+  std::string filePath = this->Makefile->GetCurrentOutputDirectory();
   std::string headerPath = filePath;
   
   // Check whether to use the old or new form.
-  if(m_Makefile->GetDefinition("VTK_USE_INSTANTIATOR_NEW"))
+  if(this->Makefile->GetDefinition("VTK_USE_INSTANTIATOR_NEW"))
     {
     oldVersion = false;
     }
@@ -70,7 +70,7 @@ cmVTKMakeInstantiatorCommand
       includesMode = false;
       if(++i < args.size())
         {
-        m_ExportMacro = args[i];
+        this->ExportMacro = args[i];
         }
       else
         {
@@ -92,12 +92,12 @@ cmVTKMakeInstantiatorCommand
         }
       else
         {
-        m_Includes.push_back(args[i]);
+        this->Includes.push_back(args[i]);
         }
       }
     }
   
-  if(m_ExportMacro == "-")
+  if(this->ExportMacro == "-")
     {
     this->SetError("No EXPORT_MACRO option given.");
     return false;
@@ -107,7 +107,7 @@ cmVTKMakeInstantiatorCommand
       s != inSourceLists.end(); ++s)
     {
     std::string srcName = cmSystemTools::GetFilenameWithoutExtension(*s);
-    cmSourceFile *sf = m_Makefile->GetSource(s->c_str());
+    cmSourceFile *sf = this->Makefile->GetSource(s->c_str());
     
     // Wrap-excluded and abstract classes do not have a New() method.
     // vtkIndent and vtkTimeStamp are special cases and are not
@@ -117,13 +117,13 @@ cmVTKMakeInstantiatorCommand
                !sf->GetPropertyAsBool("ABSTRACT"))) &&
       ((srcName != "vtkIndent") && (srcName != "vtkTimeStamp")))
       {
-      m_Classes.push_back(srcName);
+      this->Classes.push_back(srcName);
       }
     }    
   
   // Generate the header with the class declaration.
   {
-  std::string fileName = m_ClassName + ".h";
+  std::string fileName = this->ClassName + ".h";
   std::string fullName = headerPath+"/"+fileName;
   
   // Generate the output file with copy-if-different.
@@ -143,7 +143,7 @@ cmVTKMakeInstantiatorCommand
   
   // Generate the implementation file.
   {
-  std::string fileName = m_ClassName + ".cxx";
+  std::string fileName = this->ClassName + ".cxx";
   std::string fullName = filePath+"/"+fileName;
   
   // Generate the output file with copy-if-different.
@@ -167,16 +167,16 @@ cmVTKMakeInstantiatorCommand
   file.SetProperty("WRAP_EXCLUDE","1");
   file.SetProperty("ABSTRACT","0");
   file.SetName(fileName.c_str(), filePath.c_str(),
-               m_Makefile->GetSourceExtensions(),
-               m_Makefile->GetHeaderExtensions());
-  m_Makefile->AddSource(file);
+               this->Makefile->GetSourceExtensions(),
+               this->Makefile->GetHeaderExtensions());
+  this->Makefile->AddSource(file);
   sourceListValue += file.GetSourceName() + ".cxx";
   }
   
   if(oldVersion)
     {
     int groupSize = 10;
-    size_t numClasses = m_Classes.size();
+    size_t numClasses = this->Classes.size();
     size_t numFullBlocks = numClasses / groupSize;
     size_t lastBlockSize = numClasses % groupSize;
     size_t numBlocks = numFullBlocks + ((lastBlockSize>0)? 1:0);
@@ -207,15 +207,15 @@ cmVTKMakeInstantiatorCommand
       file.SetProperty("WRAP_EXCLUDE","1");
       file.SetProperty("ABSTRACT","0");
       file.SetName(fileName.c_str(), filePath.c_str(),
-                   m_Makefile->GetSourceExtensions(),
-                   m_Makefile->GetHeaderExtensions());
-      m_Makefile->AddSource(file);
+                   this->Makefile->GetSourceExtensions(),
+                   this->Makefile->GetHeaderExtensions());
+      this->Makefile->AddSource(file);
       sourceListValue += ";";
       sourceListValue += file.GetSourceName() + ".cxx";
       }
     }
   
-  m_Makefile->AddDefinition(args[1].c_str(), sourceListValue.c_str());  
+  this->Makefile->AddDefinition(args[1].c_str(), sourceListValue.c_str());  
   return true;
 }
 
@@ -226,23 +226,23 @@ cmVTKMakeInstantiatorCommand
 ::GenerateHeaderFile(std::ostream& os)
 {
   os <<
-    "#ifndef __" << m_ClassName.c_str() << "_h\n"
-    "#define __" << m_ClassName.c_str() << "_h\n"
+    "#ifndef __" << this->ClassName.c_str() << "_h\n"
+    "#define __" << this->ClassName.c_str() << "_h\n"
     "\n"
     "#include \"vtkInstantiator.h\"\n";
-  for(unsigned int i=0;i < m_Includes.size();++i)
+  for(unsigned int i=0;i < this->Includes.size();++i)
     {
-    os << "#include \"" << m_Includes[i].c_str() << "\"\n";
+    os << "#include \"" << this->Includes[i].c_str() << "\"\n";
     }
   
   // Write the instantiator class definition.
   os <<
     "\n"
-    "class " << m_ExportMacro.c_str() << " " << m_ClassName.c_str() << "\n"
+    "class " << this->ExportMacro.c_str() << " " << this->ClassName.c_str() << "\n"
     "{\n"
     "public:\n"
-    "  " << m_ClassName.c_str() << "();\n"
-    "  ~" << m_ClassName.c_str() << "();\n"
+    "  " << this->ClassName.c_str() << "();\n"
+    "  ~" << this->ClassName.c_str() << "();\n"
     "private:\n"
     "  static void ClassInitialize();\n"
     "  static void ClassFinalize();\n"
@@ -254,8 +254,8 @@ cmVTKMakeInstantiatorCommand
   // functions get registered when this generated header is included.
   os <<
     "static "
-     << m_ClassName.c_str() << " "
-     << m_ClassName.c_str() << "Initializer;\n"
+     << this->ClassName.c_str() << " "
+     << this->ClassName.c_str() << "Initializer;\n"
     "\n"
     "#endif\n";  
 }
@@ -269,41 +269,41 @@ cmVTKMakeInstantiatorCommand
 {
   // Include the instantiator class header.
   os <<
-    "#include \"" << m_ClassName.c_str() << ".h\"\n"
+    "#include \"" << this->ClassName.c_str() << ".h\"\n"
     "\n";
   
   // Write the extern declarations for all the creation functions.
-  for(unsigned int i=0;i < m_Classes.size();++i)
+  for(unsigned int i=0;i < this->Classes.size();++i)
     {
-    os << "extern vtkObject* vtkInstantiator" << m_Classes[i].c_str() 
-       << "New();\n";
+    os << "extern vtkObject* vtkInstantiator" << 
+      this->Classes[i].c_str() << "New();\n";
     }
   
   // Write the ClassInitialize method to register all the creation functions.
   os <<
     "\n"
-    "void " << m_ClassName.c_str() << "::ClassInitialize()\n"
+    "void " << this->ClassName.c_str() << "::ClassInitialize()\n"
     "{\n";
   
-  for(unsigned int i=0;i < m_Classes.size();++i)
+  for(unsigned int i=0;i < this->Classes.size();++i)
     {
     os << "  vtkInstantiator::RegisterInstantiator(\""
-       << m_Classes[i].c_str() << "\", vtkInstantiator"
-       << m_Classes[i].c_str() << "New);\n";
+       << this->Classes[i].c_str() << "\", vtkInstantiator"
+       << this->Classes[i].c_str() << "New);\n";
     }
   
   // Write the ClassFinalize method to unregister all the creation functions.
   os <<
     "}\n"
     "\n"
-    "void " << m_ClassName.c_str() << "::ClassFinalize()\n"
+    "void " << this->ClassName.c_str() << "::ClassFinalize()\n"
     "{\n";
   
-  for(unsigned int i=0;i < m_Classes.size();++i)
+  for(unsigned int i=0;i < this->Classes.size();++i)
     {
     os << "  vtkInstantiator::UnRegisterInstantiator(\""
-       << m_Classes[i].c_str() << "\", vtkInstantiator"
-       << m_Classes[i].c_str() << "New);\n";
+       << this->Classes[i].c_str() << "\", vtkInstantiator"
+       << this->Classes[i].c_str() << "New);\n";
     }
   
   // Write the constructor and destructor of the initializer class to
@@ -312,28 +312,28 @@ cmVTKMakeInstantiatorCommand
   os <<
     "}\n"
     "\n" <<
-    m_ClassName.c_str() << "::" << m_ClassName.c_str() << "()\n"
+    this->ClassName.c_str() << "::" << this->ClassName.c_str() << "()\n"
     "{\n"
-    "  if(++" << m_ClassName.c_str() << "::Count == 1)\n"
-    "    { " << m_ClassName.c_str() << "::ClassInitialize(); }\n"
+    "  if(++" << this->ClassName.c_str() << "::Count == 1)\n"
+    "    { " << this->ClassName.c_str() << "::ClassInitialize(); }\n"
     "}\n"
     "\n" <<
-    m_ClassName.c_str() << "::~" << m_ClassName.c_str() << "()\n"
+    this->ClassName.c_str() << "::~" << this->ClassName.c_str() << "()\n"
     "{\n"
-    "  if(--" << m_ClassName.c_str() << "::Count == 0)\n"
-    "    { " << m_ClassName.c_str() << "::ClassFinalize(); }\n"
+    "  if(--" << this->ClassName.c_str() << "::Count == 0)\n"
+    "    { " << this->ClassName.c_str() << "::ClassFinalize(); }\n"
     "}\n"
     "\n"
     "// Number of translation units that include this class's header.\n"
     "// Purposely not initialized.  Default is static initialization to 0.\n"
-    "unsigned int " << m_ClassName.c_str() << "::Count;\n";
+    "unsigned int " << this->ClassName.c_str() << "::Count;\n";
 }
 
 std::string
 cmVTKMakeInstantiatorCommand::OldGenerateCreationFileName(unsigned int block)
 {
   cmOStringStream nameStr;
-  nameStr << m_ClassName.c_str() << block << ".cxx";
+  nameStr << this->ClassName.c_str() << block << ".cxx";
   std::string result = nameStr.str();
   return result;
 }
@@ -348,13 +348,13 @@ cmVTKMakeInstantiatorCommand
 {
   // Need to include header of generated class.
   os <<
-    "#include \"" << m_ClassName.c_str() << ".h\"\n"
+    "#include \"" << this->ClassName.c_str() << ".h\"\n"
     "\n";
   
   // Include class files.
   for(unsigned int i=0;i < groupSize;++i)
     {
-    os << "#include \"" << m_Classes[groupStart+i].c_str() << ".h\"\n";
+    os << "#include \"" << this->Classes[groupStart+i].c_str() << ".h\"\n";
     }
 
   os <<
@@ -363,9 +363,9 @@ cmVTKMakeInstantiatorCommand
   // Write the create function implementations.
   for(unsigned int i=0;i < groupSize;++i)
     {
-    os << "vtkObject* " << m_ClassName.c_str() << "::Create_"
-       << m_Classes[groupStart+i].c_str() << "() { return "
-       << m_Classes[groupStart+i].c_str() << "::New(); }\n";
+    os << "vtkObject* " << this->ClassName.c_str() << "::Create_"
+       << this->Classes[groupStart+i].c_str() << "() { return "
+       << this->Classes[groupStart+i].c_str() << "::New(); }\n";
     }
 }
 
@@ -376,29 +376,29 @@ cmVTKMakeInstantiatorCommand
 ::OldGenerateHeaderFile(std::ostream& os)
 {
   os <<
-    "#ifndef __" << m_ClassName.c_str() << "_h\n"
-    "#define __" << m_ClassName.c_str() << "_h\n"
+    "#ifndef __" << this->ClassName.c_str() << "_h\n"
+    "#define __" << this->ClassName.c_str() << "_h\n"
     "\n"
     "#include \"vtkInstantiator.h\"\n";
-  for(unsigned int i=0;i < m_Includes.size();++i)
+  for(unsigned int i=0;i < this->Includes.size();++i)
     {
-    os << "#include \"" << m_Includes[i].c_str() << "\"\n";
+    os << "#include \"" << this->Includes[i].c_str() << "\"\n";
     }
   os <<
     "\n"
-    "class " << m_ClassName.c_str() << "Initialize;\n"
+    "class " << this->ClassName.c_str() << "Initialize;\n"
     "\n"
-    "class " << m_ExportMacro.c_str() << " " << m_ClassName.c_str() << "\n"
+    "class " << this->ExportMacro.c_str() << " " << this->ClassName.c_str() << "\n"
     "{\n"
-    "  friend class " << m_ClassName.c_str() << "Initialize;\n"
+    "  friend class " << this->ClassName.c_str() << "Initialize;\n"
     "\n"
     "  static void ClassInitialize();\n"
     "  static void ClassFinalize();\n"
     "\n";
   
-  for(unsigned int i=0;i < m_Classes.size();++i)
+  for(unsigned int i=0;i < this->Classes.size();++i)
     {
-    os << "  static vtkObject* Create_" << m_Classes[i].c_str() << "();\n";
+    os << "  static vtkObject* Create_" << this->Classes[i].c_str() << "();\n";
     }
   
   // Write the initializer class to make sure the creation functions
@@ -406,18 +406,18 @@ cmVTKMakeInstantiatorCommand
   os <<
     "};\n"
     "\n"
-    "class " << m_ExportMacro.c_str() << " " << m_ClassName.c_str() 
-     << "Initialize\n"
+    "class " << this->ExportMacro.c_str() << " " 
+     << this->ClassName.c_str() << "Initialize\n"
     "{\n"
     "public:\n"
-    "  " << m_ClassName.c_str() << "Initialize();\n"
-    "  ~" << m_ClassName.c_str() << "Initialize();\n"
+    "  " << this->ClassName.c_str() << "Initialize();\n"
+    "  ~" << this->ClassName.c_str() << "Initialize();\n"
     "private:\n"
     "  static unsigned int Count;\n"
     "};\n"
     "\n"
-    "static " << m_ClassName.c_str() << "Initialize " << m_ClassName.c_str() 
-     << "Initializer;\n"
+    "static " << this->ClassName.c_str() << "Initialize " 
+     << this->ClassName.c_str() << "Initializer;\n"
     "\n"
     "#endif\n";  
 }
@@ -431,30 +431,30 @@ cmVTKMakeInstantiatorCommand
 {
   // Write the ClassInitialize method to register all the creation functions.
   os <<
-    "#include \"" << m_ClassName.c_str() << ".h\"\n"
+    "#include \"" << this->ClassName.c_str() << ".h\"\n"
     "\n"
-    "void " << m_ClassName.c_str() << "::ClassInitialize()\n"
+    "void " << this->ClassName.c_str() << "::ClassInitialize()\n"
     "{\n";
     
-  for(unsigned int i=0;i < m_Classes.size();++i)
+  for(unsigned int i=0;i < this->Classes.size();++i)
     {
     os << "  vtkInstantiator::RegisterInstantiator(\""
-       << m_Classes[i].c_str() << "\", " << m_ClassName.c_str() << "::Create_"
-       << m_Classes[i].c_str() << ");\n";
+       << this->Classes[i].c_str() << "\", " << this->ClassName.c_str() << "::Create_"
+       << this->Classes[i].c_str() << ");\n";
     }
   
   // Write the ClassFinalize method to unregister all the creation functions.
   os <<
     "}\n"
     "\n"
-    "void " << m_ClassName.c_str() << "::ClassFinalize()\n"
+    "void " << this->ClassName.c_str() << "::ClassFinalize()\n"
     "{\n";
   
-  for(unsigned int i=0;i < m_Classes.size();++i)
+  for(unsigned int i=0;i < this->Classes.size();++i)
     {
     os << "  vtkInstantiator::UnRegisterInstantiator(\""
-       << m_Classes[i].c_str() << "\", " << m_ClassName.c_str() << "::Create_"
-       << m_Classes[i].c_str() << ");\n";
+       << this->Classes[i].c_str() << "\", " << this->ClassName.c_str() << "::Create_"
+       << this->Classes[i].c_str() << ");\n";
     }
   
   // Write the constructor and destructor of the initializer class to
@@ -463,21 +463,21 @@ cmVTKMakeInstantiatorCommand
   os <<
     "}\n"
     "\n" <<
-    m_ClassName.c_str() << "Initialize::" << m_ClassName.c_str() 
-     << "Initialize()\n"
+    this->ClassName.c_str() << "Initialize::" << 
+    this->ClassName.c_str() << "Initialize()\n"
     "{\n"
-    "  if(++" << m_ClassName.c_str() << "Initialize::Count == 1)\n"
-    "    { " << m_ClassName.c_str() << "::ClassInitialize(); }\n"
+    "  if(++" << this->ClassName.c_str() << "Initialize::Count == 1)\n"
+    "    { " << this->ClassName.c_str() << "::ClassInitialize(); }\n"
     "}\n"
     "\n" <<
-    m_ClassName.c_str() << "Initialize::~" << m_ClassName.c_str() 
-     << "Initialize()\n"
+    this->ClassName.c_str() << "Initialize::~" << 
+    this->ClassName.c_str() << "Initialize()\n"
     "{\n"
-    "  if(--" << m_ClassName.c_str() << "Initialize::Count == 0)\n"
-    "    { " << m_ClassName.c_str() << "::ClassFinalize(); }\n"
+    "  if(--" << this->ClassName.c_str() << "Initialize::Count == 0)\n"
+    "    { " << this->ClassName.c_str() << "::ClassFinalize(); }\n"
     "}\n"
     "\n"
     "// Number of translation units that include this class's header.\n"
     "// Purposely not initialized.  Default is static initialization to 0.\n"
-    "unsigned int " << m_ClassName.c_str() << "Initialize::Count;\n";
+    "unsigned int " << this->ClassName.c_str() << "Initialize::Count;\n";
 }
diff --git a/Source/cmVTKMakeInstantiatorCommand.h b/Source/cmVTKMakeInstantiatorCommand.h
index f478265..377cf75 100644
--- a/Source/cmVTKMakeInstantiatorCommand.h
+++ b/Source/cmVTKMakeInstantiatorCommand.h
@@ -78,10 +78,10 @@ public:
   cmTypeMacro(cmVTKMakeInstantiatorCommand, cmCommand);
   
 protected:
-  std::string m_ClassName;
-  std::string m_ExportMacro;
-  std::vector<cmStdString> m_Includes;
-  std::vector<cmStdString> m_Classes;
+  std::string ClassName;
+  std::string ExportMacro;
+  std::vector<cmStdString> Includes;
+  std::vector<cmStdString> Classes;
   
   void GenerateHeaderFile(std::ostream&);
   void GenerateImplementationFile(std::ostream&);
diff --git a/Source/cmVTKWrapJavaCommand.cxx b/Source/cmVTKWrapJavaCommand.cxx
index f20bbc3..3202169 100644
--- a/Source/cmVTKWrapJavaCommand.cxx
+++ b/Source/cmVTKWrapJavaCommand.cxx
@@ -25,24 +25,24 @@ bool cmVTKWrapJavaCommand::InitialPass(std::vector<std::string> const& argsIn)
     return false;
     }
   std::vector<std::string> args;
-  m_Makefile->ExpandSourceListArguments(argsIn, args, 2);
+  this->Makefile->ExpandSourceListArguments(argsIn, args, 2);
 
   // Now check and see if the value has been stored in the cache
   // already, if so use that value and don't look for the program
-  if(!m_Makefile->IsOn("VTK_WRAP_JAVA"))
+  if(!this->Makefile->IsOn("VTK_WRAP_JAVA"))
     {
     return true;
     }
 
   // what is the current source dir
-  std::string cdir = m_Makefile->GetCurrentDirectory();
+  std::string cdir = this->Makefile->GetCurrentDirectory();
 
   // keep the library name
-  m_LibraryName = args[0];
-  m_SourceList = args[1];
+  this->LibraryName = args[0];
+  this->SourceList = args[1];
   std::string sourceListValue;
   // was the list already populated
-  const char *def = m_Makefile->GetDefinition(m_SourceList.c_str());  
+  const char *def = this->Makefile->GetDefinition(this->SourceList.c_str());  
   if (def)
     {
     sourceListValue = def;
@@ -50,8 +50,9 @@ bool cmVTKWrapJavaCommand::InitialPass(std::vector<std::string> const& argsIn)
   
   // Prepare java dependency file
   const char* resultDirectory = 
-    m_Makefile->GetRequiredDefinition("VTK_JAVA_HOME");
-  std::string res = m_Makefile->GetCurrentOutputDirectory();
+          this->Makefile->GetRequiredDefinition("VTK_JAVA_HOME");
+  std::string res = this->Makefile->GetCurrentOutputDirectory();
+
   std::string depFileName = res + "/JavaDependencies.cmake";
   std::ofstream depFile(depFileName.c_str());
   depFile << "# This file is automatically generated by CMake VTK_WRAP_JAVA" 
@@ -62,7 +63,7 @@ bool cmVTKWrapJavaCommand::InitialPass(std::vector<std::string> const& argsIn)
   for(std::vector<std::string>::const_iterator j = (args.begin() + 2);
       j != args.end(); ++j)
     {   
-    cmSourceFile *curr = m_Makefile->GetSource(j->c_str());
+    cmSourceFile *curr = this->Makefile->GetSource(j->c_str());
 
     // if we should wrap the class
     if (!curr || !curr->GetPropertyAsBool("WRAP_EXCLUDE"))
@@ -74,14 +75,14 @@ bool cmVTKWrapJavaCommand::InitialPass(std::vector<std::string> const& argsIn)
         }
       std::string srcName = cmSystemTools::GetFilenameWithoutExtension(*j);
       std::string newName = srcName + "Java";
-      file.SetName(newName.c_str(), m_Makefile->GetCurrentOutputDirectory(),
+      file.SetName(newName.c_str(), this->Makefile->GetCurrentOutputDirectory(),
                    "cxx",false);
       std::string hname = cdir + "/" + srcName + ".h";
-      m_WrapHeaders.push_back(hname);
+      this->WrapHeaders.push_back(hname);
       // add starting depends
       file.GetDepends().push_back(hname);
-      m_WrapClasses.push_back(file);
-      m_OriginalNames.push_back(srcName);
+      this->WrapClasses.push_back(file);
+      this->OriginalNames.push_back(srcName);
       if (sourceListValue.size() > 0)
         {
         sourceListValue += ";";
@@ -100,22 +101,24 @@ bool cmVTKWrapJavaCommand::InitialPass(std::vector<std::string> const& argsIn)
   // Finalize java dependency file
   depFile << ")" << std::endl;
   
-  m_Makefile->AddDefinition(m_SourceList.c_str(), sourceListValue.c_str());  
+  this->Makefile->AddDefinition(this->SourceList.c_str(), sourceListValue.c_str());  
   return true;
 }
 
 void cmVTKWrapJavaCommand::FinalPass() 
 {
   // first we add the rules for all the .h to Java.cxx files
-  size_t lastClass = m_WrapClasses.size();
+  size_t lastClass = this->WrapClasses.size();
   std::vector<std::string> depends;
   std::vector<std::string> depends2;
   std::vector<std::string> alldepends;  
-  const char* wjava = m_Makefile->GetRequiredDefinition("VTK_WRAP_JAVA_EXE");
-  const char* pjava = m_Makefile->GetRequiredDefinition("VTK_PARSE_JAVA_EXE");
-  const char* hints = m_Makefile->GetDefinition("VTK_WRAP_HINTS");
+  const char* wjava = 
+    this->Makefile->GetRequiredDefinition("VTK_WRAP_JAVA_EXE");
+  const char* pjava = 
+    this->Makefile->GetRequiredDefinition("VTK_PARSE_JAVA_EXE");
+  const char* hints = this->Makefile->GetDefinition("VTK_WRAP_HINTS");
   const char* resultDirectory = 
-    m_Makefile->GetRequiredDefinition("VTK_JAVA_HOME");
+    this->Makefile->GetRequiredDefinition("VTK_JAVA_HOME");
 
   // wrap all the .h files
   depends.push_back(wjava);
@@ -127,26 +130,26 @@ void cmVTKWrapJavaCommand::FinalPass()
     }
   for(size_t classNum = 0; classNum < lastClass; classNum++)
     {
-    m_Makefile->AddSource(m_WrapClasses[classNum]);
+    this->Makefile->AddSource(this->WrapClasses[classNum]);
 
     // wrap java
-    std::string res = m_Makefile->GetCurrentOutputDirectory();
+    std::string res = this->Makefile->GetCurrentOutputDirectory();
     res += "/";
-    res += m_WrapClasses[classNum].GetSourceName() + ".cxx";
+    res += this->WrapClasses[classNum].GetSourceName() + ".cxx";
     std::string res2 = resultDirectory;
     res2 += "/";
-    res2 += m_OriginalNames[classNum];
+    res2 += this->OriginalNames[classNum];
     res2 += ".java";
     
     cmCustomCommandLine commandLineW;
     commandLineW.push_back(wjava);
-    commandLineW.push_back(m_WrapHeaders[classNum]);
+    commandLineW.push_back(this->WrapHeaders[classNum]);
     if(hints)
       {
       commandLineW.push_back(hints);
       }
-    commandLineW.push_back(
-      (m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1"));
+    commandLineW.push_back((this->WrapClasses[classNum].
+                            GetPropertyAsBool("ABSTRACT") ? "0" : "1"));
     commandLineW.push_back(res);
 
     cmCustomCommandLines commandLines;
@@ -154,32 +157,32 @@ void cmVTKWrapJavaCommand::FinalPass()
     std::vector<std::string> outputs;
     outputs.push_back(res);
     const char* no_comment = 0;
-    m_Makefile->AddCustomCommandOldStyle(m_LibraryName.c_str(),
+    this->Makefile->AddCustomCommandOldStyle(this->LibraryName.c_str(),
                                          outputs,
                                          depends,
-                                         m_WrapHeaders[classNum].c_str(),
+                                         this->WrapHeaders[classNum].c_str(),
                                          commandLines,
                                          no_comment);
 
     cmCustomCommandLine commandLineP;
     commandLineP.push_back(pjava);
-    commandLineP.push_back(m_WrapHeaders[classNum]);
+    commandLineP.push_back(this->WrapHeaders[classNum]);
     if(hints)
       {
       commandLineP.push_back(hints);
       }
-    commandLineP.push_back(
-      (m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1"));
+    commandLineP.push_back((this->WrapClasses[classNum].
+                            GetPropertyAsBool("ABSTRACT") ? "0" : "1"));
     commandLineP.push_back(res2);
 
     cmCustomCommandLines commandLines2;
     commandLines2.push_back(commandLineP);
     std::vector<std::string> outputs2;
     outputs2.push_back(res2);
-    m_Makefile->AddCustomCommandOldStyle(m_LibraryName.c_str(),
+    this->Makefile->AddCustomCommandOldStyle(this->LibraryName.c_str(),
                                          outputs2,
                                          depends2,
-                                         m_WrapHeaders[classNum].c_str(),
+                                         this->WrapHeaders[classNum].c_str(),
                                          commandLines2,
                                          no_comment);
     alldepends.push_back(res2);
@@ -187,7 +190,7 @@ void cmVTKWrapJavaCommand::FinalPass()
 
   const char* no_output = 0;
   const char* no_working_directory = 0;
-  m_Makefile->AddUtilityCommand((m_LibraryName+"JavaClasses").c_str(),
+  this->Makefile->AddUtilityCommand((this->LibraryName+"JavaClasses").c_str(),
                                 true, no_output, 
                                 alldepends, no_working_directory, "");
 }
diff --git a/Source/cmVTKWrapJavaCommand.h b/Source/cmVTKWrapJavaCommand.h
index 66de7ca..2532bd2 100644
--- a/Source/cmVTKWrapJavaCommand.h
+++ b/Source/cmVTKWrapJavaCommand.h
@@ -78,11 +78,11 @@ public:
     }
   
 private:
-  std::vector<cmSourceFile> m_WrapClasses;
-  std::vector<std::string> m_WrapHeaders;
-  std::vector<std::string> m_OriginalNames;
-  std::string m_LibraryName;
-  std::string m_SourceList;
+  std::vector<cmSourceFile> WrapClasses;
+  std::vector<std::string> WrapHeaders;
+  std::vector<std::string> OriginalNames;
+  std::string LibraryName;
+  std::string SourceList;
 };
 
 
diff --git a/Source/cmVTKWrapPythonCommand.cxx b/Source/cmVTKWrapPythonCommand.cxx
index 23b37ec..886a4ad 100644
--- a/Source/cmVTKWrapPythonCommand.cxx
+++ b/Source/cmVTKWrapPythonCommand.cxx
@@ -26,25 +26,25 @@ bool cmVTKWrapPythonCommand::InitialPass(std::vector<std::string> const&
     return false;
     }
   std::vector<std::string> args;
-  m_Makefile->ExpandSourceListArguments(argsIn, args, 2);
+  this->Makefile->ExpandSourceListArguments(argsIn, args, 2);
 
   // Now check and see if the value has been stored in the cache
   // already, if so use that value and don't look for the program
-  if(!m_Makefile->IsOn("VTK_WRAP_PYTHON"))
+  if(!this->Makefile->IsOn("VTK_WRAP_PYTHON"))
     {
     return true;
     }
 
   
   // what is the current source dir
-  std::string cdir = m_Makefile->GetCurrentDirectory();
+  std::string cdir = this->Makefile->GetCurrentDirectory();
 
   // keep the library name
-  m_LibraryName = args[0];
-  m_SourceList = args[1];
+  this->LibraryName = args[0];
+  this->SourceList = args[1];
   std::string sourceListValue;
   // was the list already populated
-  const char *def = m_Makefile->GetDefinition(m_SourceList.c_str());  
+  const char *def = this->Makefile->GetDefinition(this->SourceList.c_str());  
   if (def)
     {
     sourceListValue = def;
@@ -52,11 +52,11 @@ bool cmVTKWrapPythonCommand::InitialPass(std::vector<std::string> const&
     }
 
   // Create the init file 
-  std::string res = m_LibraryName;
+  std::string res = this->LibraryName;
   res += "Init.cxx";
 
   // add the init file
-  std::string initName = m_LibraryName;
+  std::string initName = this->LibraryName;
   initName += "Init";
   sourceListValue += initName + ".cxx";
 
@@ -64,7 +64,7 @@ bool cmVTKWrapPythonCommand::InitialPass(std::vector<std::string> const&
   for(std::vector<std::string>::iterator j = (args.begin() + 2);
       j != args.end(); ++j)
     {   
-    cmSourceFile *curr = m_Makefile->GetSource(j->c_str());
+    cmSourceFile *curr = this->Makefile->GetSource(j->c_str());
     
     // if we should wrap the class
     if (!curr || !curr->GetPropertyAsBool("WRAP_EXCLUDE"))
@@ -76,13 +76,13 @@ bool cmVTKWrapPythonCommand::InitialPass(std::vector<std::string> const&
         }
       std::string srcName = cmSystemTools::GetFilenameWithoutExtension(*j);
       std::string newName = srcName + "Python";
-      file.SetName(newName.c_str(), m_Makefile->GetCurrentOutputDirectory(),
+      file.SetName(newName.c_str(), this->Makefile->GetCurrentOutputDirectory(),
                    "cxx",false);
       std::string hname = cdir + "/" + srcName + ".h";
-      m_WrapHeaders.push_back(hname);
+      this->WrapHeaders.push_back(hname);
       // add starting depends
       file.GetDepends().push_back(hname);
-      m_WrapClasses.push_back(file);
+      this->WrapClasses.push_back(file);
       sourceListValue += ";";
       sourceListValue += newName + ".cxx";
       }
@@ -91,21 +91,21 @@ bool cmVTKWrapPythonCommand::InitialPass(std::vector<std::string> const&
   cmSourceFile cfile;
   cfile.SetProperty("ABSTRACT","0");
   this->CreateInitFile(res);
-  cfile.SetName(initName.c_str(), m_Makefile->GetCurrentOutputDirectory(),
+  cfile.SetName(initName.c_str(), this->Makefile->GetCurrentOutputDirectory(),
                 "cxx",false);
-  m_Makefile->AddSource(cfile);
-  m_Makefile->AddDefinition(m_SourceList.c_str(), sourceListValue.c_str());
+  this->Makefile->AddSource(cfile);
+  this->Makefile->AddDefinition(this->SourceList.c_str(), sourceListValue.c_str());
   return true;
 }
 
 void cmVTKWrapPythonCommand::FinalPass() 
 {
   // first we add the rules for all the .h to Python.cxx files
-  size_t lastClass = m_WrapClasses.size();
+  size_t lastClass = this->WrapClasses.size();
   std::vector<std::string> depends;
-  const char* wpython = m_Makefile->
-    GetRequiredDefinition("VTK_WRAP_PYTHON_EXE");
-  const char* hints = m_Makefile->GetDefinition("VTK_WRAP_HINTS");
+  const char* wpython = 
+    this->Makefile->GetRequiredDefinition("VTK_WRAP_PYTHON_EXE");
+  const char* hints = this->Makefile->GetDefinition("VTK_WRAP_HINTS");
 
   // wrap all the .h files
   depends.push_back(wpython);
@@ -115,19 +115,19 @@ void cmVTKWrapPythonCommand::FinalPass()
     }
   for(size_t classNum = 0; classNum < lastClass; classNum++)
     {
-    m_Makefile->AddSource(m_WrapClasses[classNum]);
-    std::string res = m_Makefile->GetCurrentOutputDirectory();
+    this->Makefile->AddSource(this->WrapClasses[classNum]);
+    std::string res = this->Makefile->GetCurrentOutputDirectory();
     res += "/";
-    res += m_WrapClasses[classNum].GetSourceName() + ".cxx";
+    res += this->WrapClasses[classNum].GetSourceName() + ".cxx";
     cmCustomCommandLine commandLine;
     commandLine.push_back(wpython);
-    commandLine.push_back(m_WrapHeaders[classNum]);
+    commandLine.push_back(this->WrapHeaders[classNum]);
     if(hints)
       {
       commandLine.push_back(hints);
       }
-    commandLine.push_back(
-      (m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1"));
+    commandLine.push_back((this->WrapClasses[classNum].
+                           GetPropertyAsBool("ABSTRACT") ? "0" : "1"));
     commandLine.push_back(res);
 
     cmCustomCommandLines commandLines;
@@ -135,10 +135,10 @@ void cmVTKWrapPythonCommand::FinalPass()
     std::vector<std::string> outputs;
     outputs.push_back(res);
     const char* no_comment = 0;
-    m_Makefile->AddCustomCommandOldStyle(m_LibraryName.c_str(),
+    this->Makefile->AddCustomCommandOldStyle(this->LibraryName.c_str(),
                                          outputs,
                                          depends,
-                                         m_WrapHeaders[classNum].c_str(),
+                                         this->WrapHeaders[classNum].c_str(),
                                          commandLines,
                                          no_comment);
     }
@@ -147,11 +147,11 @@ void cmVTKWrapPythonCommand::FinalPass()
 bool cmVTKWrapPythonCommand::CreateInitFile(std::string& res) 
 {
   std::vector<std::string> classes;
-  size_t lastClass = m_WrapHeaders.size();
+  size_t lastClass = this->WrapHeaders.size();
   size_t classNum;
   for(classNum = 0; classNum < lastClass; classNum++)
     {
-    std::string cls = m_WrapHeaders[classNum];
+    std::string cls = this->WrapHeaders[classNum];
     cls = cls.substr(0,cls.size()-2);
     std::string::size_type pos = cls.rfind('/');    
     if(pos != std::string::npos)
@@ -163,10 +163,10 @@ bool cmVTKWrapPythonCommand::CreateInitFile(std::string& res)
   
   // open the init file
   std::string outFileName = 
-    m_Makefile->GetCurrentOutputDirectory();
+    this->Makefile->GetCurrentOutputDirectory();
   outFileName += "/" + res;
   
-  return this->WriteInit(m_LibraryName.c_str(), outFileName, classes);
+  return this->WriteInit(this->LibraryName.c_str(), outFileName, classes);
 }
 
 
diff --git a/Source/cmVTKWrapPythonCommand.h b/Source/cmVTKWrapPythonCommand.h
index 1ffe139..b92b65a 100644
--- a/Source/cmVTKWrapPythonCommand.h
+++ b/Source/cmVTKWrapPythonCommand.h
@@ -85,10 +85,10 @@ public:
                          std::vector<std::string>& classes);
   
 private:
-  std::vector<cmSourceFile> m_WrapClasses;
-  std::vector<std::string> m_WrapHeaders;
-  std::string m_LibraryName;
-  std::string m_SourceList;
+  std::vector<cmSourceFile> WrapClasses;
+  std::vector<std::string> WrapHeaders;
+  std::string LibraryName;
+  std::string SourceList;
 };
 
 
diff --git a/Source/cmVTKWrapTclCommand.cxx b/Source/cmVTKWrapTclCommand.cxx
index a7c1511..de4ca9c 100644
--- a/Source/cmVTKWrapTclCommand.cxx
+++ b/Source/cmVTKWrapTclCommand.cxx
@@ -27,20 +27,20 @@ bool cmVTKWrapTclCommand::InitialPass(std::vector<std::string> const& argsIn)
   std::vector<std::string> args;
   
   // keep the library name
-  m_LibraryName = argsIn[0];
+  this->LibraryName = argsIn[0];
 
   if (argsIn[1] == std::string("SOURCES"))
     {
-    m_Makefile->ExpandSourceListArguments(argsIn, args, 3);
+    this->Makefile->ExpandSourceListArguments(argsIn, args, 3);
     }
   else
     {
-    m_Makefile->ExpandSourceListArguments(argsIn, args, 2);
+    this->Makefile->ExpandSourceListArguments(argsIn, args, 2);
     }
   
   // Now check and see if the value has been stored in the cache
   // already, if so use that value and don't look for the program
-  if(!m_Makefile->IsOn("VTK_WRAP_TCL"))
+  if(!this->Makefile->IsOn("VTK_WRAP_TCL"))
     {
     return true;
     }
@@ -68,7 +68,7 @@ bool cmVTKWrapTclCommand::InitialPass(std::vector<std::string> const& argsIn)
         }
       else
         {
-        m_Commands.push_back(*j);
+        this->Commands.push_back(*j);
         }
       }
     }
@@ -77,14 +77,14 @@ bool cmVTKWrapTclCommand::InitialPass(std::vector<std::string> const& argsIn)
   if (sources.size())
     {
     // what is the current source dir
-    std::string cdir = m_Makefile->GetCurrentDirectory();
+    std::string cdir = this->Makefile->GetCurrentDirectory();
 
     // get the resulting source list name
-    m_SourceList = sources[0];
+    this->SourceList = sources[0];
     std::string sourceListValue;
     
     // was the list already populated
-    const char *def = m_Makefile->GetDefinition(m_SourceList.c_str());  
+    const char *def = this->Makefile->GetDefinition(this->SourceList.c_str());  
     if (def)
       {
       sourceListValue = def;
@@ -92,14 +92,14 @@ bool cmVTKWrapTclCommand::InitialPass(std::vector<std::string> const& argsIn)
       }
     
     // Create the init file 
-    std::string res = m_LibraryName;
+    std::string res = this->LibraryName;
     res += "Init.cxx";
     sourceListValue += res;
     
     for(std::vector<std::string>::iterator j = (sources.begin() + 1);
         j != sources.end(); ++j)
       {   
-      cmSourceFile *curr = m_Makefile->GetSource(j->c_str());
+      cmSourceFile *curr = this->Makefile->GetSource(j->c_str());
       
       // if we should wrap the class
       if (!curr || !curr->GetPropertyAsBool("WRAP_EXCLUDE"))
@@ -114,12 +114,12 @@ bool cmVTKWrapTclCommand::InitialPass(std::vector<std::string> const& argsIn)
         std::string srcName = cmSystemTools::GetFilenameWithoutExtension(*j);
         std::string newName = srcName + "Tcl";
         std::string hname = srcDir + "/" + srcName + ".h";
-        file.SetName(newName.c_str(), m_Makefile->GetCurrentOutputDirectory(),
+        file.SetName(newName.c_str(), this->Makefile->GetCurrentOutputDirectory(),
                      "cxx",false);
-        m_WrapHeaders.push_back(hname);
+        this->WrapHeaders.push_back(hname);
         // add starting depends
         file.GetDepends().push_back(hname);
-        m_WrapClasses.push_back(file);
+        this->WrapClasses.push_back(file);
         sourceListValue += ";";
         sourceListValue += newName + ".cxx";
         }
@@ -127,13 +127,13 @@ bool cmVTKWrapTclCommand::InitialPass(std::vector<std::string> const& argsIn)
     // add the init file
     cmSourceFile cfile;
     cfile.SetProperty("ABSTRACT","0");
-    std::string newName = m_LibraryName;
+    std::string newName = this->LibraryName;
     newName += "Init";
     this->CreateInitFile(res);
-    cfile.SetName(newName.c_str(), m_Makefile->GetCurrentOutputDirectory(),
+    cfile.SetName(newName.c_str(), this->Makefile->GetCurrentOutputDirectory(),
                   "cxx",false);
-    m_Makefile->AddSource(cfile);
-    m_Makefile->AddDefinition(m_SourceList.c_str(), sourceListValue.c_str());  
+    this->Makefile->AddSource(cfile);
+    this->Makefile->AddDefinition(this->SourceList.c_str(), sourceListValue.c_str());  
     }
   
   return true;
@@ -142,10 +142,10 @@ bool cmVTKWrapTclCommand::InitialPass(std::vector<std::string> const& argsIn)
 void cmVTKWrapTclCommand::FinalPass() 
 {
   // first we add the rules for all the .h to Tcl.cxx files
-  size_t lastClass = m_WrapClasses.size();
+  size_t lastClass = this->WrapClasses.size();
   std::vector<std::string> depends;
-  const char* wtcl = m_Makefile->GetRequiredDefinition("VTK_WRAP_TCL_EXE");
-  const char* hints = m_Makefile->GetDefinition("VTK_WRAP_HINTS");
+  const char* wtcl = this->Makefile->GetRequiredDefinition("VTK_WRAP_TCL_EXE");
+  const char* hints = this->Makefile->GetDefinition("VTK_WRAP_HINTS");
 
   // wrap all the .h files
   depends.push_back(wtcl);
@@ -155,19 +155,19 @@ void cmVTKWrapTclCommand::FinalPass()
     }
   for(size_t classNum = 0; classNum < lastClass; classNum++)
     {
-    m_Makefile->AddSource(m_WrapClasses[classNum]);
+    this->Makefile->AddSource(this->WrapClasses[classNum]);
     cmCustomCommandLine commandLine;
     commandLine.push_back(wtcl);
-    commandLine.push_back(m_WrapHeaders[classNum]);
+    commandLine.push_back(this->WrapHeaders[classNum]);
     if(hints)
       {
       commandLine.push_back(hints);
       }
-    commandLine.push_back(
-      (m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT") ? "0" : "1"));
-    std::string res = m_Makefile->GetCurrentOutputDirectory();
+    commandLine.push_back((this->WrapClasses[classNum].
+                           GetPropertyAsBool("ABSTRACT") ? "0" : "1"));
+    std::string res = this->Makefile->GetCurrentOutputDirectory();
     res += "/";
-    res += m_WrapClasses[classNum].GetSourceName() + ".cxx";
+    res += this->WrapClasses[classNum].GetSourceName() + ".cxx";
     commandLine.push_back(res);
 
     cmCustomCommandLines commandLines;
@@ -175,10 +175,10 @@ void cmVTKWrapTclCommand::FinalPass()
     std::vector<std::string> outputs;
     outputs.push_back(res);
     const char* no_comment = 0;
-    m_Makefile->AddCustomCommandOldStyle(m_LibraryName.c_str(),
+    this->Makefile->AddCustomCommandOldStyle(this->LibraryName.c_str(),
                                          outputs,
                                          depends,
-                                         m_WrapHeaders[classNum].c_str(),
+                                         this->WrapHeaders[classNum].c_str(),
                                          commandLines,
                                          no_comment);
     }
@@ -187,16 +187,16 @@ void cmVTKWrapTclCommand::FinalPass()
 bool cmVTKWrapTclCommand::CreateInitFile(std::string& res) 
 {
   /* we have to make sure that the name is the correct case */
-  std::string kitName = cmSystemTools::Capitalized(m_LibraryName);
+  std::string kitName = cmSystemTools::Capitalized(this->LibraryName);
   
   std::vector<std::string> classes;
-  size_t lastClass = m_WrapHeaders.size();
+  size_t lastClass = this->WrapHeaders.size();
   size_t classNum;
   for(classNum = 0; classNum < lastClass; classNum++)
     {
-    if (!m_WrapClasses[classNum].GetPropertyAsBool("ABSTRACT"))
+    if (!this->WrapClasses[classNum].GetPropertyAsBool("ABSTRACT"))
       {
-      std::string cls = m_WrapHeaders[classNum];
+      std::string cls = this->WrapHeaders[classNum];
       cls = cls.substr(0,cls.size()-2);
       std::string::size_type pos = cls.rfind('/');    
       if(pos != std::string::npos)
@@ -209,7 +209,7 @@ bool cmVTKWrapTclCommand::CreateInitFile(std::string& res)
   
   // open the init file
   std::string outFileName = 
-    m_Makefile->GetCurrentOutputDirectory();
+    this->Makefile->GetCurrentOutputDirectory();
   outFileName += "/" + res;
   
   return this->WriteInit(kitName.c_str(), outFileName, classes);
@@ -234,9 +234,9 @@ bool cmVTKWrapTclCommand::WriteInit(const char *kitName,
 
   // capitalized commands just once
   std::vector<std::string> capcommands;
-  for (i = 0; i < m_Commands.size(); i++)
+  for (i = 0; i < this->Commands.size(); i++)
     {
-    capcommands.push_back(cmSystemTools::Capitalized(m_Commands[i]));
+    capcommands.push_back(cmSystemTools::Capitalized(this->Commands[i]));
     }
   
   fprintf(fout,"#include \"vtkTclUtil.h\"\n");
@@ -282,7 +282,7 @@ bool cmVTKWrapTclCommand::WriteInit(const char *kitName,
   fprintf(fout,"extern void vtkTclDeleteObjectFromHash(void *);\n");  
   fprintf(fout,"extern void vtkTclListInstances(Tcl_Interp *interp, ClientData arg);\n");
 
-  for (i = 0; i < m_Commands.size(); i++)
+  for (i = 0; i < this->Commands.size(); i++)
     {
     fprintf(fout,"\nextern \"C\" {int VTK_EXPORT %s_Init(Tcl_Interp *interp);}\n",
             capcommands[i].c_str());
@@ -335,7 +335,7 @@ bool cmVTKWrapTclCommand::WriteInit(const char *kitName,
                  "                    (ClientData *)NULL, NULL);\n\n");
     }
   
-  for (i = 0; i < m_Commands.size(); i++)
+  for (i = 0; i < this->Commands.size(); i++)
     {
     fprintf(fout,"  %s_Init(interp);\n", capcommands[i].c_str());
     }
@@ -348,7 +348,7 @@ bool cmVTKWrapTclCommand::WriteInit(const char *kitName,
     fprintf(fout,"                  %sCommand);\n",classes[i].c_str());
     }
   
-  fprintf(fout,"  char pkgName[]=\"%s\";\n", m_LibraryName.c_str());
+  fprintf(fout,"  char pkgName[]=\"%s\";\n", this->LibraryName.c_str());
   fprintf(fout,"  char pkgVers[]=VTK_TCL_TO_STRING(VTK_MAJOR_VERSION)"
                " \".\" "
                "VTK_TCL_TO_STRING(VTK_MINOR_VERSION);\n");
diff --git a/Source/cmVTKWrapTclCommand.h b/Source/cmVTKWrapTclCommand.h
index 610fee1..77488bc 100644
--- a/Source/cmVTKWrapTclCommand.h
+++ b/Source/cmVTKWrapTclCommand.h
@@ -87,11 +87,11 @@ public:
                          std::vector<std::string>& classes);
   
 private:
-  std::vector<cmSourceFile> m_WrapClasses;
-  std::vector<std::string> m_WrapHeaders;
-  std::string m_LibraryName;
-  std::string m_SourceList;
-  std::vector<std::string> m_Commands;
+  std::vector<cmSourceFile> WrapClasses;
+  std::vector<std::string> WrapHeaders;
+  std::string LibraryName;
+  std::string SourceList;
+  std::vector<std::string> Commands;
 };
 
 
diff --git a/Source/cmVariableRequiresCommand.cxx b/Source/cmVariableRequiresCommand.cxx
index d7b1376..b119c94 100644
--- a/Source/cmVariableRequiresCommand.cxx
+++ b/Source/cmVariableRequiresCommand.cxx
@@ -28,7 +28,7 @@ bool cmVariableRequiresCommand::InitialPass(std::vector<std::string>const&
     }
 
   std::string testVariable = args[0]; 
-  if(!m_Makefile->IsOn(testVariable.c_str()))
+  if(!this->Makefile->IsOn(testVariable.c_str()))
     {
     return true;
     }
@@ -38,26 +38,26 @@ bool cmVariableRequiresCommand::InitialPass(std::vector<std::string>const&
   bool hasAdvanced = false;
   for(unsigned int i = 2; i < args.size(); ++i)
     {
-    if(!m_Makefile->IsOn(args[i].c_str()))
+    if(!this->Makefile->IsOn(args[i].c_str()))
       {
       requirementsMet = false;
       notSet += args[i];
       notSet += "\n";
       cmCacheManager::CacheIterator it = 
-        m_Makefile->GetCacheManager()->GetCacheIterator(args[i].c_str());
+        this->Makefile->GetCacheManager()->GetCacheIterator(args[i].c_str());
       if(!it.IsAtEnd() && it.GetPropertyAsBool("ADVANCED"))
         {
         hasAdvanced = true;
         }
       }
     }
-  const char* reqVar = m_Makefile->GetDefinition(resultVariable.c_str());
+  const char* reqVar = this->Makefile->GetDefinition(resultVariable.c_str());
   // if reqVar is unset, then set it to requirementsMet 
   // if reqVar is set to true, but requirementsMet is false , then
   // set reqVar to false.
-  if(!reqVar || (!requirementsMet && m_Makefile->IsOn(reqVar)))
+  if(!reqVar || (!requirementsMet && this->Makefile->IsOn(reqVar)))
     {
-    m_Makefile->AddDefinition(resultVariable.c_str(), requirementsMet);
+    this->Makefile->AddDefinition(resultVariable.c_str(), requirementsMet);
     }
 
   if(!requirementsMet)
diff --git a/Source/cmVariableWatch.cxx b/Source/cmVariableWatch.cxx
index b54ff87..d267a52 100644
--- a/Source/cmVariableWatch.cxx
+++ b/Source/cmVariableWatch.cxx
@@ -28,14 +28,14 @@ void cmVariableWatch::AddWatch(const std::string& variable,
                                WatchMethod method, void* client_data /*=0*/)
 {
   cmVariableWatch::Pair p;
-  p.m_Method = method;
-  p.m_ClientData = client_data;
-  cmVariableWatch::VectorOfPairs* vp = &m_WatchMap[variable];
+  p.Method = method;
+  p.ClientData = client_data;
+  cmVariableWatch::VectorOfPairs* vp = &this->WatchMap[variable];
   cmVariableWatch::VectorOfPairs::size_type cc;
   for ( cc = 0; cc < vp->size(); cc ++ )
     {
     cmVariableWatch::Pair* pair = &(*vp)[cc];
-    if ( pair->m_Method == method )
+    if ( pair->Method == method )
       {
       (*vp)[cc] = p;
       return;
@@ -47,11 +47,11 @@ void cmVariableWatch::AddWatch(const std::string& variable,
 void cmVariableWatch::RemoveWatch(const std::string& variable, 
                                   WatchMethod method)
 {
-  cmVariableWatch::VectorOfPairs* vp = &m_WatchMap[variable];
+  cmVariableWatch::VectorOfPairs* vp = &this->WatchMap[variable];
   cmVariableWatch::VectorOfPairs::iterator it;
   for ( it = vp->begin(); it != vp->end(); ++it )
     {
-    if ( it->m_Method == method )
+    if ( it->Method == method )
       {
       vp->erase(it);
       return;
@@ -63,14 +63,14 @@ void  cmVariableWatch::VariableAccessed(const std::string& variable,
                                         int access_type) const
 {
   cmVariableWatch::StringToVectorOfPairs::const_iterator mit = 
-    m_WatchMap.find(variable);
-  if ( mit  != m_WatchMap.end() )
+    this->WatchMap.find(variable);
+  if ( mit  != this->WatchMap.end() )
     {
     const cmVariableWatch::VectorOfPairs* vp = &mit->second;
     cmVariableWatch::VectorOfPairs::const_iterator it;
     for ( it = vp->begin(); it != vp->end(); it ++ )
       {
-      it->m_Method(variable, access_type, it->m_ClientData);
+      it->Method(variable, access_type, it->ClientData);
       }
     }
 }
diff --git a/Source/cmVariableWatch.h b/Source/cmVariableWatch.h
index 44bddc5..15e8f90 100644
--- a/Source/cmVariableWatch.h
+++ b/Source/cmVariableWatch.h
@@ -61,15 +61,15 @@ public:
 protected:
   struct Pair
   {
-    WatchMethod m_Method;
-    void*        m_ClientData;
-    Pair() : m_Method(0), m_ClientData(0) {}
+    WatchMethod Method;
+    void*        ClientData;
+    Pair() : Method(0), ClientData(0) {}
   };
 
   typedef std::vector< Pair > VectorOfPairs;
   typedef std::map<cmStdString, VectorOfPairs > StringToVectorOfPairs;
 
-  StringToVectorOfPairs m_WatchMap;
+  StringToVectorOfPairs WatchMap;
 };
 
 
diff --git a/Source/cmWhileCommand.cxx b/Source/cmWhileCommand.cxx
index 012018e..3c785d7 100644
--- a/Source/cmWhileCommand.cxx
+++ b/Source/cmWhileCommand.cxx
@@ -22,31 +22,31 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
 {
   // Prevent recusion and don't let this blocker block its own
   // commands.
-  if (m_Executing)
+  if (this->Executing)
     {
     return false;
     }
   
   // at end of for each execute recorded commands
-  if (cmSystemTools::LowerCase(lff.m_Name) == "endwhile")
+  if (cmSystemTools::LowerCase(lff.Name) == "endwhile")
     {
     char* errorString = 0;
     
     std::vector<std::string> expandedArguments;
-    mf.ExpandArguments(m_Args, expandedArguments);
+    mf.ExpandArguments(this->Args, expandedArguments);
     bool isTrue = 
       cmIfCommand::IsTrue(expandedArguments,&errorString,&mf);
 
-    m_Executing = true;
+    this->Executing = true;
     while (isTrue)
       {      
       // Invoke all the functions that were collected in the block.
-      for(unsigned int c = 0; c < m_Functions.size(); ++c)
+      for(unsigned int c = 0; c < this->Functions.size(); ++c)
         {
-        mf.ExecuteCommand(m_Functions[c]);
+        mf.ExecuteCommand(this->Functions[c]);
         }
       expandedArguments.clear();
-      mf.ExpandArguments(m_Args, expandedArguments);
+      mf.ExpandArguments(this->Args, expandedArguments);
       isTrue = 
         cmIfCommand::IsTrue(expandedArguments,&errorString,&mf);
       }
@@ -55,7 +55,7 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
     }
 
   // record the command
-  m_Functions.push_back(lff);
+  this->Functions.push_back(lff);
   
   // always return true
   return true;
@@ -64,9 +64,9 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf)
 bool cmWhileFunctionBlocker::
 ShouldRemove(const cmListFileFunction& lff, cmMakefile& )
 {
-  if(cmSystemTools::LowerCase(lff.m_Name) == "endwhile")
+  if(cmSystemTools::LowerCase(lff.Name) == "endwhile")
     {
-    if (lff.m_Arguments == m_Args)
+    if (lff.Arguments == this->Args)
       {
       return true;
       }
@@ -94,8 +94,8 @@ bool cmWhileCommand::InvokeInitialPass(
   
   // create a function blocker
   cmWhileFunctionBlocker *f = new cmWhileFunctionBlocker();
-  f->m_Args = args;
-  m_Makefile->AddFunctionBlocker(f);
+  f->Args = args;
+  this->Makefile->AddFunctionBlocker(f);
   
   return true;
 }
diff --git a/Source/cmWhileCommand.h b/Source/cmWhileCommand.h
index 4e34147..10c261c 100644
--- a/Source/cmWhileCommand.h
+++ b/Source/cmWhileCommand.h
@@ -29,16 +29,16 @@
 class cmWhileFunctionBlocker : public cmFunctionBlocker
 {
 public:
-  cmWhileFunctionBlocker() {m_Executing = false;}
+  cmWhileFunctionBlocker() {Executing = false;}
   virtual ~cmWhileFunctionBlocker() {}
   virtual bool IsFunctionBlocked(const cmListFileFunction& lff,
                                  cmMakefile &mf);
   virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf);
   virtual void ScopeEnded(cmMakefile &mf);
   
-  std::vector<cmListFileArgument> m_Args;
-  std::vector<cmListFileFunction> m_Functions;
-  bool m_Executing;
+  std::vector<cmListFileArgument> Args;
+  std::vector<cmListFileFunction> Functions;
+  bool Executing;
 };
 
 /** \class cmWhileCommand
diff --git a/Source/cmWin32ProcessExecution.cxx b/Source/cmWin32ProcessExecution.cxx
index d41ad58..88b0127 100644
--- a/Source/cmWin32ProcessExecution.cxx
+++ b/Source/cmWin32ProcessExecution.cxx
@@ -264,7 +264,7 @@ bool cmWin32ProcessExecution::StartProcess(
   const char* cmd, const char* path, bool verbose)
 {
   this->Initialize();
-  m_Verbose = verbose;
+  this->Verbose = verbose;
   return this->PrivateOpen(cmd, path, _O_RDONLY | _O_TEXT, POPEN_3);
 }
 
@@ -505,7 +505,7 @@ bool cmWin32ProcessExecution::PrivateOpen(const char *cmdstring,
   
   if (!CreatePipe(&this->hChildStdinRd, &this->hChildStdinWr, &saAttr, 0))
     {
-    m_Output += "CreatePipeError\n";
+    this->Output += "CreatePipeError\n";
     return false;
     }
     
@@ -519,7 +519,7 @@ bool cmWin32ProcessExecution::PrivateOpen(const char *cmdstring,
                              DUPLICATE_SAME_ACCESS);
   if (!fSuccess)
     {
-    m_Output += "DuplicateHandleError\n";
+    this->Output += "DuplicateHandleError\n";
     return false;
     }
 
@@ -530,7 +530,7 @@ bool cmWin32ProcessExecution::PrivateOpen(const char *cmdstring,
 
   if (!CreatePipe(&this->hChildStdoutRd, &this->hChildStdoutWr, &saAttr, 0))
     {
-    m_Output += "CreatePipeError\n";
+    this->Output += "CreatePipeError\n";
     return false;
     }
 
@@ -539,7 +539,7 @@ bool cmWin32ProcessExecution::PrivateOpen(const char *cmdstring,
                              FALSE, DUPLICATE_SAME_ACCESS);
   if (!fSuccess)
     {
-    m_Output += "DuplicateHandleError\n";
+    this->Output += "DuplicateHandleError\n";
     return false;
     }
 
@@ -551,7 +551,7 @@ bool cmWin32ProcessExecution::PrivateOpen(const char *cmdstring,
     {
     if (!CreatePipe(&this->hChildStderrRd, &this->hChildStderrWr, &saAttr, 0))
       {
-      m_Output += "CreatePipeError\n";
+      this->Output += "CreatePipeError\n";
       return false;
       }
    fSuccess = DuplicateHandle(GetCurrentProcess(),
@@ -561,7 +561,7 @@ bool cmWin32ProcessExecution::PrivateOpen(const char *cmdstring,
                               FALSE, DUPLICATE_SAME_ACCESS);
     if (!fSuccess)
       {
-      m_Output += "DuplicateHandleError\n";
+      this->Output += "DuplicateHandleError\n";
       return false;
       }
     /* Close the inheritable version of ChildStdErr that we're using. */
@@ -628,24 +628,24 @@ bool cmWin32ProcessExecution::PrivateOpen(const char *cmdstring,
     {
     if (!RealPopenCreateProcess(cmdstring,
                                 path,
-                                m_ConsoleSpawn.c_str(),
+                                this->ConsoleSpawn.c_str(),
                                 this->hChildStdinRd,
                                 this->hChildStdoutWr,
                                 this->hChildStdoutWr,
-                                &hProcess, m_HideWindows,
-                                m_Output))
+                                &hProcess, this->HideWindows,
+                                this->Output))
       return 0;
     }
   else 
     {
     if (!RealPopenCreateProcess(cmdstring,
                                 path,
-                                m_ConsoleSpawn.c_str(),
+                                this->ConsoleSpawn.c_str(),
                                 this->hChildStdinRd,
                                 this->hChildStdoutWr,
                                 this->hChildStderrWr,
-                                &hProcess, m_HideWindows,
-                                m_Output))
+                                &hProcess, this->HideWindows,
+                                this->Output))
       return 0;
     }
 
@@ -666,21 +666,21 @@ bool cmWin32ProcessExecution::PrivateOpen(const char *cmdstring,
    * make sure that no handles to the write end of the output pipe
    * are maintained in this process or else the pipe will not close
    * when the child process exits and the ReadFile will hang. */
-  m_ProcessHandle = hProcess;
+  this->ProcessHandle = hProcess;
   if ( fd1 >= 0 )
     {
-    //  m_StdIn = f1;
-    m_pStdIn = fd1;
+    //  this->StdIn = f1;
+    this->pStdIn = fd1;
     }
   if ( fd2 >= 0 )
     {
-    //  m_StdOut = f2;
-    m_pStdOut = fd2;
+    //  this->StdOut = f2;
+    this->pStdOut = fd2;
     }
   if ( fd3 >= 0 )
     {
-    //  m_StdErr = f3;
-    m_pStdErr = fd3;
+    //  this->StdErr = f3;
+    this->pStdErr = fd3;
     }
 
   return true;
@@ -691,37 +691,37 @@ bool cmWin32ProcessExecution::CloseHandles()
   bool ret = true;
   if (this->hChildStdinRd && !CloseHandle(this->hChildStdinRd))
     {
-    m_Output += "CloseHandleError\n";
+    this->Output += "CloseHandleError\n";
     ret = false;
     }
   this->hChildStdinRd = 0;
   if(this->hChildStdoutRdDup && !CloseHandle(this->hChildStdoutRdDup))
     {
-    m_Output += "CloseHandleError\n";
+    this->Output += "CloseHandleError\n";
     ret = false;
     }
   this->hChildStdoutRdDup = 0;
   if(this->hChildStderrRdDup && !CloseHandle(this->hChildStderrRdDup))
     {
-    m_Output += "CloseHandleError\n";
+    this->Output += "CloseHandleError\n";
     ret = false;
     }
   this->hChildStderrRdDup = 0;
   if(this->hChildStdinWrDup && !CloseHandle(this->hChildStdinWrDup))
     {
-    m_Output += "CloseHandleError\n";
+    this->Output += "CloseHandleError\n";
     ret = false;
     }
   this->hChildStdinWrDup = 0;
   if (this->hChildStdoutWr && !CloseHandle(this->hChildStdoutWr))
     {
-    m_Output += "CloseHandleError\n";
+    this->Output += "CloseHandleError\n";
     ret = false;
     }
   this->hChildStdoutWr = 0;
   if (this->hChildStderrWr && !CloseHandle(this->hChildStderrWr))
     {
-    m_Output += "CloseHandleError\n";
+    this->Output += "CloseHandleError\n";
     ret = false;
     }
   this->hChildStderrWr = 0;
@@ -771,7 +771,7 @@ cmWin32ProcessExecution::~cmWin32ProcessExecution()
 
 bool cmWin32ProcessExecution::PrivateClose(int /* timeout */)
 {
-  HANDLE hProcess = m_ProcessHandle;
+  HANDLE hProcess = this->ProcessHandle;
 
   int result = -1;
   DWORD exit_code;
@@ -784,8 +784,8 @@ bool cmWin32ProcessExecution::PrivateClose(int /* timeout */)
     bool have_some = false;
     struct _stat fsout;
     struct _stat fserr;
-    int rout = _fstat(m_pStdOut, &fsout);
-    int rerr = _fstat(m_pStdErr, &fserr);
+    int rout = _fstat(this->pStdOut, &fsout);
+    int rerr = _fstat(this->pStdErr, &fserr);
     if ( rout && rerr )
       {
       break;
@@ -793,9 +793,9 @@ bool cmWin32ProcessExecution::PrivateClose(int /* timeout */)
     if (fserr.st_size > 0)
       {
       char buffer[1024];
-      int len = read(m_pStdErr, buffer, 1023);
+      int len = read(this->pStdErr, buffer, 1023);
       buffer[len] = 0;
-      if ( m_Verbose )
+      if ( this->Verbose )
         {
         cmSystemTools::Stdout(buffer);
         }
@@ -805,9 +805,9 @@ bool cmWin32ProcessExecution::PrivateClose(int /* timeout */)
     if (fsout.st_size > 0)
       {
       char buffer[1024];
-      int len = read(m_pStdOut, buffer, 1023);
+      int len = read(this->pStdOut, buffer, 1023);
       buffer[len] = 0;
-      if ( m_Verbose )
+      if ( this->Verbose )
         {
         cmSystemTools::Stdout(buffer);
         }
@@ -851,8 +851,8 @@ bool cmWin32ProcessExecution::PrivateClose(int /* timeout */)
 
   /* Free up the native handle at this point */
   CloseHandle(hProcess);
-  m_ExitValue = result;
-  m_Output += output;
+  this->ExitValue = result;
+  this->Output += output;
   bool ret = this->CloseHandles();
   if ( result < 0 || !ret)
     {
diff --git a/Source/cmWin32ProcessExecution.h b/Source/cmWin32ProcessExecution.h
index 6f6d8b7..9f58374 100644
--- a/Source/cmWin32ProcessExecution.h
+++ b/Source/cmWin32ProcessExecution.h
@@ -45,13 +45,13 @@ class cmWin32ProcessExecution
 public:
   cmWin32ProcessExecution()
     {
-    m_HideWindows = false;
+    this->HideWindows = false;
     this->SetConsoleSpawn("w9xpopen.exe");
     this->Initialize();
     }
   ~cmWin32ProcessExecution();
   ///! If true windows will be created hidden.
-  void SetHideWindows(bool v) { m_HideWindows = v;  }
+  void SetHideWindows(bool v) { this->HideWindows = v;  }
   
   /**
    * Initialize the process execution datastructure. Do not call while
@@ -59,16 +59,16 @@ public:
    */
   void Initialize() 
     {
-    this->m_ProcessHandle = 0;
-    this->m_ExitValue    = -1;
+    this->ProcessHandle = 0;
+    this->ExitValue    = -1;
     // Comment this out. Maybe we will need it in the future.
     // file IO access to the process might be cool.
-    //this->m_StdIn  =  0;
-    //this->m_StdOut =  0;
-    //this->m_StdErr =  0;
-    this->m_pStdIn  =  -1;
-    this->m_pStdOut =  -1;
-    this->m_pStdErr =  -1;
+    //this->StdIn  =  0;
+    //this->StdOut =  0;
+    //this->StdErr =  0;
+    this->pStdIn  =  -1;
+    this->pStdOut =  -1;
+    this->pStdErr =  -1;
     }
   
   /**
@@ -90,13 +90,13 @@ public:
    * Get the output of the process (mixed stdout and stderr) as
    * std::string.
    */
-  const std::string GetOutput() const { return this->m_Output; }
+  const std::string GetOutput() const { return this->Output; }
 
   /**
    * Get the return value of the process. If the process is still
    * running, the return value is -1.
    */
-  int GetExitValue() const { return this->m_ExitValue; }
+  int GetExitValue() const { return this->ExitValue; }
 
   /**
    * On Windows 9x there is a bug in the process execution code which
@@ -104,7 +104,7 @@ public:
    * used. Specify the console spawn, which should run the
    * Windows9xHack code.
    */
-  void SetConsoleSpawn(const char* prog) { this->m_ConsoleSpawn = prog; }
+  void SetConsoleSpawn(const char* prog) { this->ConsoleSpawn = prog; }
   static int Windows9xHack(const char* command);
 
   /** Code from a Borland web site with the following explaination :
@@ -144,7 +144,7 @@ private:
   bool PrivateOpen(const char*, const char*, int, int);
   bool PrivateClose(int timeout);
 
-  HANDLE m_ProcessHandle;
+  HANDLE ProcessHandle;
   HANDLE hChildStdinRd;
   HANDLE hChildStdinWr;
   HANDLE hChildStdoutRd;
@@ -156,16 +156,16 @@ private:
   HANDLE hChildStderrRdDup;
   
   
-  int m_pStdIn;
-  int m_pStdOut;
-  int m_pStdErr;
+  int pStdIn;
+  int pStdOut;
+  int pStdErr;
 
-  int m_ExitValue;
+  int ExitValue;
 
-  std::string m_Output;
-  std::string m_ConsoleSpawn;
-  bool m_Verbose;
-  bool m_HideWindows;
+  std::string Output;
+  std::string ConsoleSpawn;
+  bool Verbose;
+  bool HideWindows;
 };
 
 
diff --git a/Source/cmWriteFileCommand.cxx b/Source/cmWriteFileCommand.cxx
index 144b219..9093c04 100644
--- a/Source/cmWriteFileCommand.cxx
+++ b/Source/cmWriteFileCommand.cxx
@@ -82,7 +82,7 @@ bool cmWriteFileCommand::InitialPass(std::vector<std::string> const& args)
   file << message << std::endl;
   file.close();
   cmSystemTools::SetPermissions(fileName.c_str(), mode);
-  m_Makefile->AddWrittenFile(fileName.c_str());
+  this->Makefile->AddWrittenFile(fileName.c_str());
 
   return true;
 }
diff --git a/Source/cmXCode21Object.cxx b/Source/cmXCode21Object.cxx
index cd94c1d..e383c22 100644
--- a/Source/cmXCode21Object.cxx
+++ b/Source/cmXCode21Object.cxx
@@ -4,23 +4,23 @@
 cmXCode21Object::cmXCode21Object(PBXType ptype, Type type)
   :cmXCodeObject(ptype, type)
 {
-  m_Version = 21;
+  this->Version = 21;
 }
 
 //----------------------------------------------------------------------------
 void cmXCode21Object::PrintComment(std::ostream& out)
 {
-  if(m_Comment.size() == 0)
+  if(this->Comment.size() == 0)
     {
     cmXCodeObject* n = this->GetObject("name");
     if(n)
       {
-      m_Comment = n->GetString();
-      cmSystemTools::ReplaceString(m_Comment, "\"", "");
+      this->Comment = n->GetString();
+      cmSystemTools::ReplaceString(this->Comment, "\"", "");
       }
     }
   out << "/* ";
-  out << m_Comment;
+  out << this->Comment;
   out << " */";
 }
 
diff --git a/Source/cmXCodeObject.cxx b/Source/cmXCodeObject.cxx
index 4474b72..da6bcfb 100644
--- a/Source/cmXCodeObject.cxx
+++ b/Source/cmXCodeObject.cxx
@@ -15,43 +15,43 @@ const char* cmXCodeObject::PBXTypeNames[] = {
 
 cmXCodeObject::~cmXCodeObject()
 {
-  m_Version = 15;
+  this->Version = 15;
 }
 
 
 //----------------------------------------------------------------------------
 cmXCodeObject::cmXCodeObject(PBXType ptype, Type type)
 {
-  m_Version = 15;
-  m_PBXTargetDependency = 0;
-  m_cmTarget = 0;
-  m_Object =0;
+  this->Version = 15;
+  this->PBXTargetDependency = 0;
+  this->cmTarget = 0;
+  this->Object =0;
   
-  m_IsA = ptype;
+  this->IsA = ptype;
   if(type == OBJECT)
     {
     cmOStringStream str;
     str << (void*)this;
     str << (void*)this;
     str << (void*)this;
-    m_Id = str.str();
+    this->Id = str.str();
     }
   else
     {
-    m_Id = "Temporary cmake object, should not be refered to in xcode file";
+    this->Id = "Temporary cmake object, should not be refered to in xcode file";
     }
-  cmSystemTools::ReplaceString(m_Id, "0x", "");
-  m_Id = cmSystemTools::UpperCase(m_Id);
-  if(m_Id.size() < 24)
+  cmSystemTools::ReplaceString(this->Id, "0x", "");
+  this->Id = cmSystemTools::UpperCase(this->Id);
+  if(this->Id.size() < 24)
     {
-    int diff = 24 - m_Id.size();
+    int diff = 24 - this->Id.size();
     for(int i =0; i < diff; ++i)
       {
-      m_Id += "0";
+      this->Id += "0";
       }
     }
-  m_Type = type;
-  if(m_Type == OBJECT)
+  this->Type = type;
+  if(this->Type == OBJECT)
     {
     this->AddAttribute("isa", 0);
     }
@@ -72,14 +72,14 @@ void cmXCodeObject::Print(std::ostream& out)
 {
   std::string separator = "\n";
   int indentFactor = 1;
-  if(m_Version > 15 && (m_IsA == PBXFileReference || m_IsA == PBXBuildFile))
+  if(this->Version > 15 && (this->IsA == PBXFileReference || this->IsA == PBXBuildFile))
     {
     separator = " ";
     indentFactor = 0;
     }
   cmXCodeObject::Indent(2*indentFactor, out);
-  out << m_Id << " ";
-  if(!(this->m_IsA == PBXGroup && this->m_Comment.size() == 0))
+  out << this->Id << " ";
+  if(!(this->this->IsA == PBXGroup && this->this->Comment.size() == 0))
     {
     this->PrintComment(out);
     }
@@ -90,8 +90,8 @@ void cmXCodeObject::Print(std::ostream& out)
     }
   std::map<cmStdString, cmXCodeObject*>::iterator i;
   cmXCodeObject::Indent(3*indentFactor, out);
-  out << "isa = " << PBXTypeNames[m_IsA]  << ";" << separator;
-  for(i = m_ObjectAttributes.begin(); i != m_ObjectAttributes.end(); ++i)
+  out << "isa = " << PBXTypeNames[this->IsA]  << ";" << separator;
+  for(i = this->ObjectAttributes.begin(); i != this->ObjectAttributes.end(); ++i)
     { 
     cmXCodeObject* object = i->second;
     if(i->first != "isa")
@@ -102,46 +102,46 @@ void cmXCodeObject::Print(std::ostream& out)
       {
       continue;
       }
-    if(object->m_Type == OBJECT_LIST)
+    if(object->this->Type == OBJECT_LIST)
       {
       out << i->first << " = (" << separator;
-      for(unsigned int k = 0; k < i->second->m_List.size(); k++)
+      for(unsigned int k = 0; k < i->second->this->List.size(); k++)
         {
         cmXCodeObject::Indent(4*indentFactor, out);
-        out << i->second->m_List[k]->m_Id << " ";
-        i->second->m_List[k]->PrintComment(out);
+        out << i->second->this->List[k]->this->Id << " ";
+        i->second->this->List[k]->PrintComment(out);
         out << "," << separator;
         } 
       cmXCodeObject::Indent(3*indentFactor, out);
       out << ");" << separator;
       }
-    else if(object->m_Type == ATTRIBUTE_GROUP)
+    else if(object->this->Type == ATTRIBUTE_GROUP)
       {
       std::map<cmStdString, cmXCodeObject*>::iterator j;
       out << i->first << " = {" << separator;
-      for(j = object->m_ObjectAttributes.begin(); j != 
-            object->m_ObjectAttributes.end(); ++j)
+      for(j = object->ObjectAttributes.begin(); j != 
+            object->ObjectAttributes.end(); ++j)
         {
         cmXCodeObject::Indent(4 *indentFactor, out);
-        out << j->first << " = " << j->second->m_String << ";";
+        out << j->first << " = " << j->second->this->String << ";";
         out << separator;
         }
       cmXCodeObject::Indent(3 *indentFactor, out);
       out << "};" << separator;
       }
-    else if(object->m_Type == OBJECT_REF)
+    else if(object->this->Type == OBJECT_REF)
       {
-      out << i->first << " = " << object->m_Object->m_Id;
-      if(object->m_Object->HasComment() && i->first != "remoteGlobalIDString")
+      out << i->first << " = " << object->this->Object->this->Id;
+      if(object->this->Object->HasComment() && i->first != "remoteGlobalIDString")
         {
         out << " ";
-        object->m_Object->PrintComment(out);
+        object->this->Object->PrintComment(out);
         }
       out << ";" << separator;
       }
-    else if(object->m_Type == STRING)
+    else if(object->this->Type == STRING)
       {
-      out << i->first << " = " << object->m_String << ";" << separator;
+      out << i->first << " = " << object->this->String << ";" << separator;
       }
     else
       {
@@ -160,7 +160,7 @@ void cmXCodeObject::PrintList(std::vector<cmXCodeObject*> const& objs,
   out << "objects = {\n";
   for(unsigned int i = 0; i < objs.size(); ++i)
     {
-    if(objs[i]->m_Type == OBJECT)
+    if(objs[i]->this->Type == OBJECT)
       {
       objs[i]->Print(out);
       }
@@ -172,10 +172,10 @@ void cmXCodeObject::PrintList(std::vector<cmXCodeObject*> const& objs,
 
 void cmXCodeObject::CopyAttributes(cmXCodeObject* copy)
 {
-  this->m_ObjectAttributes = copy->m_ObjectAttributes;
-  this->m_List = copy->m_List;
-  this->m_String = copy->m_String;
-  this->m_Object = copy->m_Object;
+  this->this->ObjectAttributes = copy->this->ObjectAttributes;
+  this->this->List = copy->this->List;
+  this->this->String = copy->this->String;
+  this->this->Object = copy->this->Object;
 }
 
 void cmXCodeObject::SetString(const char* s)
@@ -183,22 +183,22 @@ void cmXCodeObject::SetString(const char* s)
   std::string ss = s;
   if(ss.size() == 0)
     {
-    m_String = "\"\"";
+    this->String = "\"\"";
     return;
     }
   bool needQuote = false;
-  m_String = "";
+  this->String = "";
   if(ss.find_first_of(" <>.+-=") != ss.npos)
     {
     needQuote = true;
     }
   if(needQuote)
     {
-    m_String = "\"";
+    this->String = "\"";
     }
-  m_String += s;
+  this->String += s;
   if(needQuote)
     {
-    m_String += "\"";
+    this->String += "\"";
     }
 }
diff --git a/Source/cmXCodeObject.h b/Source/cmXCodeObject.h
index 11a7088..e564c6f 100644
--- a/Source/cmXCodeObject.h
+++ b/Source/cmXCodeObject.h
@@ -22,41 +22,41 @@ public:
   static const char* PBXTypeNames[];
   virtual ~cmXCodeObject();
   cmXCodeObject(PBXType ptype, Type type);
-  Type GetType() { return m_Type;}
-  PBXType GetIsA() { return m_IsA;}
+  Type GetType() { return this->Type;}
+  PBXType GetIsA() { return this->IsA;}
 
   void SetString(const char* s);
   const char* GetString() 
     {
-      return m_String.c_str();
+      return this->String.c_str();
     }
   
   void AddAttribute(const char* name, cmXCodeObject* value)
     {
-      m_ObjectAttributes[name] = value;
+      this->ObjectAttributes[name] = value;
     }
   
   void SetObject(cmXCodeObject* value)
     {
-      m_Object = value;
+      this->Object = value;
     }
   cmXCodeObject* GetObject()
     {
-      return m_Object;
+      return this->Object;
     }
   void AddObject(cmXCodeObject* value)
     {
-      m_List.push_back(value);
+      this->List.push_back(value);
     }
   bool HasObject(cmXCodeObject* o)
     {
-      return !(std::find(m_List.begin(), m_List.end(), o) == m_List.end());
+      return !(std::find(this->List.begin(), this->List.end(), o) == this->List.end());
     }
   void AddUniqueObject(cmXCodeObject* value)
     {
-      if(std::find(m_List.begin(), m_List.end(), value) == m_List.end())
+      if(std::find(this->List.begin(), this->List.end(), value) == this->List.end())
         {
-        m_List.push_back(value);
+        this->List.push_back(value);
         }
     }
   static void Indent(int level, std::ostream& out);
@@ -66,34 +66,34 @@ public:
   static void PrintList(std::vector<cmXCodeObject*> const&, std::ostream& out);
   const char* GetId()
     {
-      return m_Id.c_str();
+      return this->Id.c_str();
     }
   cmTarget* GetcmTarget()
     {
-      return m_cmTarget;
+      return this->cmTarget;
     }
   void SetcmTarget(cmTarget* t)
     {
-      m_cmTarget = t;
+      this->cmTarget = t;
     }
-  const char* GetComment() {return m_Comment.c_str();}
-  bool HasComment() { return (m_Comment.size() !=  0);}
+  const char* GetComment() {return this->Comment.c_str();}
+  bool HasComment() { return (this->Comment.size() !=  0);}
   cmXCodeObject* GetObject(const char* name)
     {
-      if(m_ObjectAttributes.count(name))
+      if(this->ObjectAttributes.count(name))
         {
-        return m_ObjectAttributes[name];
+        return this->ObjectAttributes[name];
         }
       return 0;
     }
   // serach the attribute list for an object of the specified type
   cmXCodeObject* GetObject(cmXCodeObject::PBXType t)
     {
-      for(std::vector<cmXCodeObject*>::iterator i = m_List.begin();
-          i != m_List.end(); ++i)
+      for(std::vector<cmXCodeObject*>::iterator i = this->List.begin();
+          i != this->List.end(); ++i)
         {
         cmXCodeObject* o = *i;
-        if(o->m_IsA == t)
+        if(o->this->IsA == t)
           {
           return o;
           }
@@ -103,11 +103,11 @@ public:
   
   cmXCodeObject* GetPBXTargetDependency()
     {
-      return m_PBXTargetDependency;
+      return this->PBXTargetDependency;
     }
   void SetPBXTargetDependency(cmXCodeObject* d)
     {
-      m_PBXTargetDependency = d;
+      this->PBXTargetDependency = d;
     }
   void CopyAttributes(cmXCodeObject* );
   
@@ -118,26 +118,26 @@ public:
         {
         configName = "";
         }
-      m_DependLibraries[configName].push_back(l);
+      this->DependLibraries[configName].push_back(l);
     }
   std::map<cmStdString, StringVec> const& GetDependLibraries()
     {
-      return m_DependLibraries;
+      return this->DependLibraries;
     }
-  std::vector<cmXCodeObject*> const& GetObjectList() { return m_List;}
-  void SetComment(const char* c) { m_Comment = c;}
+  std::vector<cmXCodeObject*> const& GetObjectList() { return this->List;}
+  void SetComment(const char* c) { this->Comment = c;}
 protected:
-  cmTarget* m_cmTarget;
-  Type m_Type;
-  cmStdString m_Id;
-  PBXType m_IsA;
-  int m_Version;
-  cmStdString m_Comment;
-  cmStdString m_String;
-  cmXCodeObject* m_Object;
-  cmXCodeObject* m_PBXTargetDependency;
-  std::vector<cmXCodeObject*> m_List;
-  std::map<cmStdString, StringVec> m_DependLibraries;
-  std::map<cmStdString, cmXCodeObject*> m_ObjectAttributes;
+  cmTarget* cmTarget;
+  Type Type;
+  cmStdString Id;
+  PBXType IsA;
+  int Version;
+  cmStdString Comment;
+  cmStdString String;
+  cmXCodeObject* Object;
+  cmXCodeObject* PBXTargetDependency;
+  std::vector<cmXCodeObject*> List;
+  std::map<cmStdString, StringVec> DependLibraries;
+  std::map<cmStdString, cmXCodeObject*> ObjectAttributes;
 };
 #endif
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index 61458b6..9496720 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -104,17 +104,17 @@ void cmNeedBackwardsCompatibility(const std::string& variable,
 
 cmake::cmake()
 {
-  m_DebugTryCompile = false;
-  m_ClearBuildSystem = false;
-  m_FileComparison = new cmFileTimeComparison;
+  this->DebugTryCompile = false;
+  this->ClearBuildSystem = false;
+  this->FileComparison = new cmFileTimeComparison;
 
 #ifdef __APPLE__
   struct rlimit rlp;
   if(!getrlimit(RLIMIT_STACK, &rlp))
     {
-    if(rlp.rlim_cur != rlp.rlim_max)
+    if(rlp.rlithis->cur != rlp.rlithis->max)
       {
-        rlp.rlim_cur = rlp.rlim_max;
+        rlp.rlithis->cur = rlp.rlithis->max;
          setrlimit(RLIMIT_STACK, &rlp);
       }
     }
@@ -130,21 +130,21 @@ cmake::cmake()
     cmSystemTools::PutEnv("MAKEFLAGS=");
     }
 
-  m_Verbose = false;
-  m_InTryCompile = false;
-  m_CacheManager = new cmCacheManager;
-  m_GlobalGenerator = 0;
-  m_ProgressCallback = 0;
-  m_ProgressCallbackClientData = 0;
-  m_ScriptMode = false;
+  this->Verbose = false;
+  this->InTryCompile = false;
+  this->CacheManager = new cmCacheManager;
+  this->GlobalGenerator = 0;
+  this->ProgressCallback = 0;
+  this->ProgressCallbackClientData = 0;
+  this->ScriptMode = false;
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
-  m_VariableWatch = new cmVariableWatch;
-  m_VariableWatch->AddWatch("CMAKE_WORDS_BIGENDIAN",
+  this->VariableWatch = new cmVariableWatch;
+  this->VariableWatch->AddWatch("CMAKE_WORDS_BIGENDIAN",
                             cmNeedBackwardsCompatibility);
-  m_VariableWatch->AddWatch("CMAKE_SIZEOF_INT",
+  this->VariableWatch->AddWatch("CMAKE_SIZEOF_INT",
                             cmNeedBackwardsCompatibility);
-  m_VariableWatch->AddWatch("CMAKE_X_LIBS",
+  this->VariableWatch->AddWatch("CMAKE_X_LIBS",
                             cmNeedBackwardsCompatibility);
 #endif
 
@@ -157,28 +157,28 @@ cmake::cmake()
 
 cmake::~cmake()
 {
-  delete m_CacheManager;
-  if (m_GlobalGenerator)
+  delete this->CacheManager;
+  if (this->GlobalGenerator)
     {
-    delete m_GlobalGenerator;
-    m_GlobalGenerator = 0;
+    delete this->GlobalGenerator;
+    this->GlobalGenerator = 0;
     }
-  for(RegisteredCommandsMap::iterator j = m_Commands.begin();
-      j != m_Commands.end(); ++j)
+  for(RegisteredCommandsMap::iterator j = this->Commands.begin();
+      j != this->Commands.end(); ++j)
     {
     delete (*j).second;
     }
 #ifdef CMAKE_BUILD_WITH_CMAKE
-  delete m_VariableWatch;
+  delete this->VariableWatch;
 #endif
-  delete m_FileComparison;
+  delete this->FileComparison;
 }
 
 void cmake::CleanupCommandsAndMacros()
 {
   std::vector<cmCommand*> commands;
-  for(RegisteredCommandsMap::iterator j = m_Commands.begin();
-      j != m_Commands.end(); ++j)
+  for(RegisteredCommandsMap::iterator j = this->Commands.begin();
+      j != this->Commands.end(); ++j)
     {
     if ( !j->second->IsA("cmMacroHelperCommand") )
       {
@@ -189,27 +189,27 @@ void cmake::CleanupCommandsAndMacros()
       delete j->second;
       }
     }
-  m_Commands.erase(m_Commands.begin(), m_Commands.end());
+  this->Commands.erase(this->Commands.begin(), this->Commands.end());
   std::vector<cmCommand*>::iterator it;
   for ( it = commands.begin(); it != commands.end();
     ++ it )
     {
-    m_Commands[cmSystemTools::LowerCase((*it)->GetName())] = *it;
+    this->Commands[cmSystemTools::LowerCase((*it)->GetName())] = *it;
     }
 }
 
 bool cmake::CommandExists(const char* name) const
 {
   std::string sName = cmSystemTools::LowerCase(name);
-  return (m_Commands.find(sName) != m_Commands.end());
+  return (this->Commands.find(sName) != this->Commands.end());
 }
 
 cmCommand *cmake::GetCommand(const char *name)
 {
   cmCommand* rm = 0;
   std::string sName = cmSystemTools::LowerCase(name);
-  RegisteredCommandsMap::iterator pos = m_Commands.find(sName);
-  if (pos != m_Commands.end())
+  RegisteredCommandsMap::iterator pos = this->Commands.find(sName);
+  if (pos != this->Commands.end())
     {
     rm = (*pos).second;
     }
@@ -221,35 +221,35 @@ void cmake::RenameCommand(const char*oldName, const char* newName)
   // if the command already exists, free the old one
   std::string sOldName = cmSystemTools::LowerCase(oldName);
   std::string sNewName = cmSystemTools::LowerCase(newName);
-  RegisteredCommandsMap::iterator pos = m_Commands.find(sOldName);
-  if ( pos == m_Commands.end() )
+  RegisteredCommandsMap::iterator pos = this->Commands.find(sOldName);
+  if ( pos == this->Commands.end() )
     {
     return;
     }
   cmCommand* cmd = pos->second;
 
-  pos = m_Commands.find(sNewName);
-  if (pos != m_Commands.end())
+  pos = this->Commands.find(sNewName);
+  if (pos != this->Commands.end())
     {
     delete pos->second;
-    m_Commands.erase(pos);
+    this->Commands.erase(pos);
     }
-  m_Commands.insert(RegisteredCommandsMap::value_type(sNewName, cmd));
-  pos = m_Commands.find(sOldName);
-  m_Commands.erase(pos);
+  this->Commands.insert(RegisteredCommandsMap::value_type(sNewName, cmd));
+  pos = this->Commands.find(sOldName);
+  this->Commands.erase(pos);
 }
 
 void cmake::AddCommand(cmCommand* wg)
 {
   std::string name = cmSystemTools::LowerCase(wg->GetName());
   // if the command already exists, free the old one
-  RegisteredCommandsMap::iterator pos = m_Commands.find(name);
-  if (pos != m_Commands.end())
+  RegisteredCommandsMap::iterator pos = this->Commands.find(name);
+  if (pos != this->Commands.end())
     {
     delete pos->second;
-    m_Commands.erase(pos);
+    this->Commands.erase(pos);
     }
-  m_Commands.insert( RegisteredCommandsMap::value_type(name, wg));
+  this->Commands.insert( RegisteredCommandsMap::value_type(name, wg));
 }
 
 // Parse the args
@@ -270,7 +270,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
       if(cmCacheManager::ParseEntry(entry.c_str(), var, value, type) ||
         cmCacheManager::ParseEntry(entry.c_str(), var, value))
         {
-        this->m_CacheManager->AddCacheEntry(var.c_str(), value.c_str(),
+        this->CacheManager->AddCacheEntry(var.c_str(), value.c_str(),
           "No help, variable specified on the command line.",
           type);
         }
@@ -380,12 +380,12 @@ void cmake::SetArgs(const std::vector<std::string>& args)
       }
     else if((i < args.size()-1) && (arg.find("--check-build-system",0) == 0))
       {
-      m_CheckBuildSystem = args[++i];
-      m_ClearBuildSystem = (atoi(args[++i].c_str()) > 0);
+      this->CheckBuildSystemArgument = args[++i];
+      this->ClearBuildSystem = (atoi(args[++i].c_str()) > 0);
       }
     else if(arg.find("-V",0) == 0)
       {
-        m_Verbose = true;
+        this->Verbose = true;
       }
     else if(arg.find("-D",0) == 0)
       {
@@ -405,8 +405,8 @@ void cmake::SetArgs(const std::vector<std::string>& args)
       std::string path = arg.substr(strlen("--graphviz="));
       path = cmSystemTools::CollapseFullPath(path.c_str());
       cmSystemTools::ConvertToUnixSlashes(path);
-      m_GraphVizFile = path;
-      if ( m_GraphVizFile.empty() )
+      this->GraphVizFile = path;
+      if ( this->GraphVizFile.empty() )
         {
         cmSystemTools::Error("No file specified for --graphviz");
         }
@@ -615,7 +615,7 @@ int cmake::AddCMakePaths(const char *arg0)
     return 0;
     }
   // Save the value in the cache
-  this->m_CacheManager->AddCacheEntry
+  this->CacheManager->AddCacheEntry
     ("CMAKE_COMMAND",cMakeSelf.c_str(), "Path to CMake executable.",
      cmCacheManager::INTERNAL);
 
@@ -631,13 +631,13 @@ int cmake::AddCMakePaths(const char *arg0)
     "/ctest" + cmSystemTools::GetFilenameExtension(cMakeSelf);
   if(cmSystemTools::FileExists(ctestCommand.c_str()))
     {
-    this->m_CacheManager->AddCacheEntry
+    this->CacheManager->AddCacheEntry
       ("CMAKE_CTEST_COMMAND", ctestCommand.c_str(),
        "Path to ctest program executable.", cmCacheManager::INTERNAL);
     }
   if(cmSystemTools::FileExists(editCacheCommand.c_str()))
     {
-    this->m_CacheManager->AddCacheEntry
+    this->CacheManager->AddCacheEntry
       ("CMAKE_EDIT_COMMAND", editCacheCommand.c_str(),
        "Path to cache edit program executable.", cmCacheManager::INTERNAL);
     }
@@ -708,7 +708,7 @@ int cmake::AddCMakePaths(const char *arg0)
       cMakeRoot.c_str());
     return 0;
     }
-  this->m_CacheManager->AddCacheEntry
+  this->CacheManager->AddCacheEntry
     ("CMAKE_ROOT", cMakeRoot.c_str(),
      "Path to CMake installation.", cmCacheManager::INTERNAL);
 
@@ -761,7 +761,7 @@ void CMakeCommandUsage(const char* program)
   cmSystemTools::Error(errorStream.str().c_str());
 }
 
-int cmake::CMakeCommand(std::vector<std::string>& args)
+int cmake::ExecuteCMakeCommand(std::vector<std::string>& args)
 {
   if (args.size() > 1)
     {
@@ -1078,8 +1078,8 @@ int cmake::CMakeCommand(std::vector<std::string>& args)
 
 void cmake::GetRegisteredGenerators(std::vector<std::string>& names)
 {
-  for(RegisteredGeneratorsMap::const_iterator i = m_Generators.begin();
-      i != m_Generators.end(); ++i)
+  for(RegisteredGeneratorsMap::const_iterator i = this->Generators.begin();
+      i != this->Generators.end(); ++i)
     {
     names.push_back(i->first);
     }
@@ -1087,8 +1087,8 @@ void cmake::GetRegisteredGenerators(std::vector<std::string>& names)
 
 cmGlobalGenerator* cmake::CreateGlobalGenerator(const char* name)
 {
-  RegisteredGeneratorsMap::const_iterator i = m_Generators.find(name);
-  if(i != m_Generators.end())
+  RegisteredGeneratorsMap::const_iterator i = this->Generators.find(name);
+  if(i != this->Generators.end())
     {
     cmGlobalGenerator* generator = (i->second)();
     generator->SetCMakeInstance(this);
@@ -1102,62 +1102,62 @@ cmGlobalGenerator* cmake::CreateGlobalGenerator(const char* name)
 
 void cmake::SetHomeDirectory(const char* dir)
 {
-  m_cmHomeDirectory = dir;
-  cmSystemTools::ConvertToUnixSlashes(m_cmHomeDirectory);
+  this->cmHomeDirectory = dir;
+  cmSystemTools::ConvertToUnixSlashes(this->cmHomeDirectory);
 }
 
 void cmake::SetHomeOutputDirectory(const char* lib)
 {
-  m_HomeOutputDirectory = lib;
-  cmSystemTools::ConvertToUnixSlashes(m_HomeOutputDirectory);
+  this->HomeOutputDirectory = lib;
+  cmSystemTools::ConvertToUnixSlashes(this->HomeOutputDirectory);
 }
 
 void cmake::SetGlobalGenerator(cmGlobalGenerator *gg)
 {
   // delete the old generator
-  if (m_GlobalGenerator)
+  if (this->GlobalGenerator)
     {
-    delete m_GlobalGenerator;
+    delete this->GlobalGenerator;
     // restore the original environment variables CXX and CC
     // Restor CC
     std::string env = "CC=";
-    if(m_CCEnvironment.size())
+    if(this->CCEnvironment.size())
       {
-      env += m_CCEnvironment;
+      env += this->CCEnvironment;
       }
     cmSystemTools::PutEnv(env.c_str());
     env = "CXX=";
-    if(m_CXXEnvironment.size())
+    if(this->CXXEnvironment.size())
       {
-      env += m_CXXEnvironment;
+      env += this->CXXEnvironment;
       }
     cmSystemTools::PutEnv(env.c_str());
     }
 
   // set the new
-  m_GlobalGenerator = gg;
-  // set the global flag for unix style paths on cmSystemTools as
+  this->GlobalGenerator = gg;
+  // set the global flag for unix style paths on cmSystemTools as 
   // soon as the generator is set.  This allows gmake to be used
   // on windows.
-  cmSystemTools::SetForceUnixPaths(m_GlobalGenerator->GetForceUnixPaths());
+  cmSystemTools::SetForceUnixPaths(this->GlobalGenerator->GetForceUnixPaths());
   // Save the environment variables CXX and CC
   const char* cxx = getenv("CXX");
   const char* cc = getenv("CC");
   if(cxx)
     {
-    m_CXXEnvironment = cxx;
+    this->CXXEnvironment = cxx;
     }
   else
     {
-    m_CXXEnvironment = "";
+    this->CXXEnvironment = "";
     }
   if(cc)
     {
-    m_CCEnvironment = cc;
+    this->CCEnvironment = cc;
     }
   else
     {
-    m_CCEnvironment = "";
+    this->CCEnvironment = "";
     }
   // set the cmake instance just to be sure
   gg->SetCMakeInstance(this);
@@ -1193,10 +1193,10 @@ int cmake::DoPreConfigureChecks()
     }
 
   // do a sanity check on some values
-  if(m_CacheManager->GetCacheValue("CMAKE_HOME_DIRECTORY"))
+  if(this->CacheManager->GetCacheValue("CMAKE_HOME_DIRECTORY"))
     {
-    std::string cacheStart =
-      m_CacheManager->GetCacheValue("CMAKE_HOME_DIRECTORY");
+    std::string cacheStart = 
+      this->CacheManager->GetCacheValue("CMAKE_HOME_DIRECTORY");
     cacheStart += "/CMakeLists.txt";
     std::string currentStart = this->GetHomeDirectory();
     currentStart += "/CMakeLists.txt";
@@ -1226,7 +1226,7 @@ int cmake::Configure()
   this->CleanupCommandsAndMacros();
 
   int res = 0;
-  if ( !m_ScriptMode )
+  if ( !this->ScriptMode )
     {
     res = this->DoPreConfigureChecks();
     }
@@ -1236,41 +1236,42 @@ int cmake::Configure()
     }
   if ( !res )
     {
-    m_CacheManager->AddCacheEntry("CMAKE_HOME_DIRECTORY",
-      this->GetHomeDirectory(),
-      "Start directory with the top level CMakeLists.txt file for this "
-      "project",
-      cmCacheManager::INTERNAL);
+    this->CacheManager->AddCacheEntry
+      ("CMAKE_HOME_DIRECTORY", 
+       this->GetHomeDirectory(),
+       "Start directory with the top level CMakeLists.txt file for this "
+       "project",
+       cmCacheManager::INTERNAL);
     }
 
   // set the default BACKWARDS compatibility to the current version
-  if(!m_CacheManager->GetCacheValue("CMAKE_BACKWARDS_COMPATIBILITY"))
+  if(!this->CacheManager->GetCacheValue("CMAKE_BACKWARDS_COMPATIBILITY"))
     {
     char ver[256];
     sprintf(ver,"%i.%i",cmMakefile::GetMajorVersion(),
             cmMakefile::GetMinorVersion());
-    this->m_CacheManager->AddCacheEntry
-      ("CMAKE_BACKWARDS_COMPATIBILITY",ver,
+    this->CacheManager->AddCacheEntry
+      ("CMAKE_BACKWARDS_COMPATIBILITY",ver, 
        "For backwards compatibility, what version of CMake commands and "
        "syntax should this version of CMake allow.",
        cmCacheManager::STRING);
     }
 
   // no generator specified on the command line
-  if(!m_GlobalGenerator)
+  if(!this->GlobalGenerator)
     {
-    const char* genName = m_CacheManager->GetCacheValue("CMAKE_GENERATOR");
+    const char* genName = this->CacheManager->GetCacheValue("CMAKE_GENERATOR");
     if(genName)
       {
-      m_GlobalGenerator = this->CreateGlobalGenerator(genName);
+      this->GlobalGenerator = this->CreateGlobalGenerator(genName);
       }
-    if(m_GlobalGenerator)
+    if(this->GlobalGenerator)
       {
       // set the global flag for unix style paths on cmSystemTools as
       // soon as the generator is set.  This allows gmake to be used
       // on windows.
-      cmSystemTools::SetForceUnixPaths(
-        m_GlobalGenerator->GetForceUnixPaths());
+      cmSystemTools::SetForceUnixPaths
+        (this->GlobalGenerator->GetForceUnixPaths());
       }
     else
       {
@@ -1320,20 +1321,20 @@ int cmake::Configure()
       this->SetGlobalGenerator(new cmGlobalUnixMakefileGenerator3);
 #endif
       }
-    if(!m_GlobalGenerator)
+    if(!this->GlobalGenerator)
       {
       cmSystemTools::Error("Could not create generator");
       return -1;
       }
     }
 
-  const char* genName = m_CacheManager->GetCacheValue("CMAKE_GENERATOR");
+  const char* genName = this->CacheManager->GetCacheValue("CMAKE_GENERATOR");
   if(genName)
     {
-    if(strcmp(m_GlobalGenerator->GetName(), genName) != 0)
+    if(strcmp(this->GlobalGenerator->GetName(), genName) != 0)
       {
       std::string message = "Error: generator : ";
-      message += m_GlobalGenerator->GetName();
+      message += this->GlobalGenerator->GetName();
       message += "\nDoes not match the generator used previously: ";
       message += genName;
       message +=
@@ -1343,57 +1344,60 @@ int cmake::Configure()
       return -2;
       }
     }
-  if(!m_CacheManager->GetCacheValue("CMAKE_GENERATOR"))
+  if(!this->CacheManager->GetCacheValue("CMAKE_GENERATOR"))
     {
-    m_CacheManager->AddCacheEntry("CMAKE_GENERATOR",
-                                  m_GlobalGenerator->GetName(),
-                                  "Name of generator.",
-                                  cmCacheManager::INTERNAL);
+    this->CacheManager->AddCacheEntry("CMAKE_GENERATOR", 
+                                      this->GlobalGenerator->GetName(),
+                                      "Name of generator.",
+                                      cmCacheManager::INTERNAL);
     }
 
   // reset any system configuration information, except for when we are
   // InTryCompile. With TryCompile the system info is taken from the parent's
   // info to save time
-  if (!m_InTryCompile)
+  if (!this->InTryCompile)
     {
-    m_GlobalGenerator->ClearEnabledLanguages();
+    this->GlobalGenerator->ClearEnabledLanguages();
     }
 
   this->CleanupWrittenFiles();
 
   // Truncate log files
-  if (!m_InTryCompile)
+  if (!this->InTryCompile)
     {
     this->TruncateOutputLog("CMakeOutput.log");
     this->TruncateOutputLog("CMakeError.log");
     }
 
   // actually do the configure
-  m_GlobalGenerator->Configure();
-
+  this->GlobalGenerator->Configure();
+  
   // Before saving the cache
   // if the project did not define one of the entries below, add them now
   // so users can edit the values in the cache:
   // LIBRARY_OUTPUT_PATH
   // EXECUTABLE_OUTPUT_PATH
-  if(!m_CacheManager->GetCacheValue("LIBRARY_OUTPUT_PATH"))
-    {
-    m_CacheManager->AddCacheEntry("LIBRARY_OUTPUT_PATH", "",
-      "Single output directory for building all libraries.",
-      cmCacheManager::PATH);
-    }
-  if(!m_CacheManager->GetCacheValue("EXECUTABLE_OUTPUT_PATH"))
-    {
-    m_CacheManager->AddCacheEntry("EXECUTABLE_OUTPUT_PATH", "",
-      "Single output directory for building all executables.",
-      cmCacheManager::PATH);
-    }
-  if(!m_CacheManager->GetCacheValue("CMAKE_USE_RELATIVE_PATHS"))
-    {
-    m_CacheManager->AddCacheEntry("CMAKE_USE_RELATIVE_PATHS", false,
-      "If true, cmake will use relative paths in makefiles and projects.");
+  if(!this->CacheManager->GetCacheValue("LIBRARY_OUTPUT_PATH"))
+    {
+    this->CacheManager->AddCacheEntry
+      ("LIBRARY_OUTPUT_PATH", "",
+       "Single output directory for building all libraries.",
+       cmCacheManager::PATH);
+    } 
+  if(!this->CacheManager->GetCacheValue("EXECUTABLE_OUTPUT_PATH"))
+    {
+    this->CacheManager->AddCacheEntry
+      ("EXECUTABLE_OUTPUT_PATH", "",
+       "Single output directory for building all executables.",
+       cmCacheManager::PATH);
+    }  
+  if(!this->CacheManager->GetCacheValue("CMAKE_USE_RELATIVE_PATHS"))
+    {
+    this->CacheManager->AddCacheEntry
+      ("CMAKE_USE_RELATIVE_PATHS", false,
+       "If true, cmake will use relative paths in makefiles and projects.");
     cmCacheManager::CacheIterator it =
-      m_CacheManager->GetCacheIterator("CMAKE_USE_RELATIVE_PATHS");
+      this->CacheManager->GetCacheIterator("CMAKE_USE_RELATIVE_PATHS");
     if ( !it.PropertyExists("ADVANCED") )
       {
       it.SetProperty("ADVANCED", "1");
@@ -1401,23 +1405,23 @@ int cmake::Configure()
     }
 
   if(cmSystemTools::GetFatalErrorOccured() &&
-     (!this->m_CacheManager->GetCacheValue("CMAKE_MAKE_PROGRAM") ||
-      cmSystemTools::IsOff(
-        this->m_CacheManager->GetCacheValue("CMAKE_MAKE_PROGRAM"))))
+     (!this->CacheManager->GetCacheValue("CMAKE_MAKE_PROGRAM") ||
+      cmSystemTools::IsOff(this->CacheManager->
+                           GetCacheValue("CMAKE_MAKE_PROGRAM"))))
     {
     // We must have a bad generator selection.  Wipe the cache entry so the
     // user can select another.
-    m_CacheManager->RemoveCacheEntry("CMAKE_GENERATOR");
+    this->CacheManager->RemoveCacheEntry("CMAKE_GENERATOR");
     }
   // only save the cache if there were no fatal errors
-  if ( !m_ScriptMode && !cmSystemTools::GetFatalErrorOccured() )
+  if ( !this->ScriptMode && !cmSystemTools::GetFatalErrorOccured() )
     {
-    this->m_CacheManager->SaveCache(this->GetHomeOutputDirectory());
+    this->CacheManager->SaveCache(this->GetHomeOutputDirectory());
     }
-  if ( !m_GraphVizFile.empty() )
+  if ( !this->GraphVizFile.empty() )
     {
-    std::cout << "Generate graphviz: " << m_GraphVizFile << std::endl;
-    this->GenerateGraphViz(m_GraphVizFile.c_str());
+    std::cout << "Generate graphviz: " << this->GraphVizFile << std::endl;
+    this->GenerateGraphViz(this->GraphVizFile.c_str());
     }
   if(cmSystemTools::GetErrorOccuredFlag())
     {
@@ -1428,12 +1432,12 @@ int cmake::Configure()
 
 bool cmake::CacheVersionMatches()
 {
-  const char* majv
-    = m_CacheManager->GetCacheValue("CMAKE_CACHE_MAJOR_VERSION");
-  const char* minv
-    = m_CacheManager->GetCacheValue("CMAKE_CACHE_MINOR_VERSION");
-  const char* relv
-    = m_CacheManager->GetCacheValue("CMAKE_CACHE_RELEASE_VERSION");
+  const char* majv = 
+    this->CacheManager->GetCacheValue("CMAKE_CACHE_MAJOR_VERSION");
+  const char* minv = 
+    this->CacheManager->GetCacheValue("CMAKE_CACHE_MINOR_VERSION");
+  const char* relv = 
+    this->CacheManager->GetCacheValue("CMAKE_CACHE_RELEASE_VERSION");
   bool cacheSameCMake = false;
   if(majv &&
      atoi(majv) == static_cast<int>(cmMakefile::GetMajorVersion())
@@ -1480,9 +1484,9 @@ int cmake::Run(const std::vector<std::string>& args, bool noconfigure)
     }
 
   // set the cmake command
-  m_CMakeCommand = args[0];
-
-  if ( !m_ScriptMode )
+  this->CMakeCommand = args[0];
+  
+  if ( !this->ScriptMode )
     {
     // load the cache
     if(this->LoadCache() < 0)
@@ -1493,7 +1497,7 @@ int cmake::Run(const std::vector<std::string>& args, bool noconfigure)
     }
   else
     {
-    this->AddCMakePaths(m_CMakeCommand.c_str());
+    this->AddCMakePaths(this->CMakeCommand.c_str());
     }
 
   // Add any cache args
@@ -1504,7 +1508,7 @@ int cmake::Run(const std::vector<std::string>& args, bool noconfigure)
     }
 
   // In script mode we terminate after running the script.
-  if(m_ScriptMode)
+  if(this->ScriptMode)
     {
     if(cmSystemTools::GetErrorOccuredFlag())
       {
@@ -1540,7 +1544,7 @@ int cmake::Run(const std::vector<std::string>& args, bool noconfigure)
   this->SetStartDirectory(this->GetHomeDirectory());
   this->SetStartOutputDirectory(this->GetHomeOutputDirectory());
   int ret = this->Configure();
-  if (ret || m_ScriptMode)
+  if (ret || this->ScriptMode)
     {
     return ret;
     }
@@ -1560,11 +1564,11 @@ int cmake::Run(const std::vector<std::string>& args, bool noconfigure)
 
 int cmake::Generate()
 {
-  if(!m_GlobalGenerator)
+  if(!this->GlobalGenerator)
     {
     return -1;
     }
-  m_GlobalGenerator->Generate();
+  this->GlobalGenerator->Generate();
   if(cmSystemTools::GetErrorOccuredFlag())
     {
     return -1;
@@ -1591,14 +1595,14 @@ void cmake::AddCacheEntry(const char* key, const char* value,
                           const char* helpString,
                           int type)
 {
-  m_CacheManager->AddCacheEntry(key, value,
-                                helpString,
-                                cmCacheManager::CacheEntryType(type));
+  this->CacheManager->AddCacheEntry(key, value, 
+                                    helpString,
+                                    cmCacheManager::CacheEntryType(type));
 }
 
 const char* cmake::GetCacheDefinition(const char* name) const
 {
-  return m_CacheManager->GetCacheValue(name);
+  return this->CacheManager->GetCacheValue(name);
 }
 
 int cmake::DumpDocumentationToFile(std::ostream& f)
@@ -1614,8 +1618,8 @@ int cmake::DumpDocumentationToFile(std::ostream& f)
   f << "<html>\n";
   f << "<h1>Documentation for commands of CMake " << tmp << "</h1>\n";
   f << "<ul>\n";
-  for(RegisteredCommandsMap::iterator j = m_Commands.begin();
-      j != m_Commands.end(); ++j)
+  for(RegisteredCommandsMap::iterator j = this->Commands.begin();
+      j != this->Commands.end(); ++j)
     {
     name = (*j).second->GetName();
     terse = (*j).second->GetTerseDocumentation();
@@ -1646,34 +1650,34 @@ void cmake::AddDefaultGenerators()
 {
 #if defined(_WIN32) && !defined(__CYGWIN__)
 # if !defined(CMAKE_BOOT_MINGW)
-  m_Generators[cmGlobalVisualStudio6Generator::GetActualName()] =
+  this->Generators[cmGlobalVisualStudio6Generator::GetActualName()] =
     &cmGlobalVisualStudio6Generator::New;
-  m_Generators[cmGlobalVisualStudio7Generator::GetActualName()] =
+  this->Generators[cmGlobalVisualStudio7Generator::GetActualName()] =
     &cmGlobalVisualStudio7Generator::New;
-  m_Generators[cmGlobalVisualStudio71Generator::GetActualName()] =
+  this->Generators[cmGlobalVisualStudio71Generator::GetActualName()] =
     &cmGlobalVisualStudio71Generator::New;
-  m_Generators[cmGlobalVisualStudio8Generator::GetActualName()] =
+  this->Generators[cmGlobalVisualStudio8Generator::GetActualName()] =
     &cmGlobalVisualStudio8Generator::New;
-  m_Generators[cmGlobalBorlandMakefileGenerator::GetActualName()] =
+  this->Generators[cmGlobalBorlandMakefileGenerator::GetActualName()] =
     &cmGlobalBorlandMakefileGenerator::New;
-  m_Generators[cmGlobalNMakeMakefileGenerator::GetActualName()] =
+  this->Generators[cmGlobalNMakeMakefileGenerator::GetActualName()] =
     &cmGlobalNMakeMakefileGenerator::New;
-  m_Generators[cmGlobalWatcomWMakeGenerator::GetActualName()] =
+  this->Generators[cmGlobalWatcomWMakeGenerator::GetActualName()] =
     &cmGlobalWatcomWMakeGenerator::New;
 # endif
-  m_Generators[cmGlobalMSYSMakefileGenerator::GetActualName()] =
+  this->Generators[cmGlobalMSYSMakefileGenerator::GetActualName()] =
     &cmGlobalMSYSMakefileGenerator::New;
-  m_Generators[cmGlobalMinGWMakefileGenerator::GetActualName()] =
+  this->Generators[cmGlobalMinGWMakefileGenerator::GetActualName()] =
     &cmGlobalMinGWMakefileGenerator::New;
 #endif
-  m_Generators[cmGlobalUnixMakefileGenerator3::GetActualName()] =
+  this->Generators[cmGlobalUnixMakefileGenerator3::GetActualName()] =
     &cmGlobalUnixMakefileGenerator3::New;
 #ifdef CMAKE_USE_XCODE
-  m_Generators[cmGlobalXCodeGenerator::GetActualName()] =
+  this->Generators[cmGlobalXCodeGenerator::GetActualName()] =
     &cmGlobalXCodeGenerator::New;
 #endif
 #ifdef CMAKE_USE_KDEVELOP
-  m_Generators[cmGlobalKdevelopGenerator::GetActualName()] =
+  this->Generators[cmGlobalKdevelopGenerator::GetActualName()] =
      &cmGlobalKdevelopGenerator::New;
 #endif
 }
@@ -1681,7 +1685,7 @@ void cmake::AddDefaultGenerators()
 int cmake::LoadCache()
 {
   // could we not read the cache
-  if (!m_CacheManager->LoadCache(this->GetHomeOutputDirectory()))
+  if (!this->CacheManager->LoadCache(this->GetHomeOutputDirectory()))
     {
     // if it does exist, but isn;t readable then warn the user
     std::string cacheFile = this->GetHomeOutputDirectory();
@@ -1696,7 +1700,7 @@ int cmake::LoadCache()
       }
     }
 
-  if (m_CMakeCommand.size() < 2)
+  if (this->CMakeCommand.size() < 2)
     {
     cmSystemTools::Error(
       "cmake command was not specified prior to loading the cache in "
@@ -1705,19 +1709,19 @@ int cmake::LoadCache()
     }
 
   // setup CMAKE_ROOT and CMAKE_COMMAND
-  if(!this->AddCMakePaths(m_CMakeCommand.c_str()))
+  if(!this->AddCMakePaths(this->CMakeCommand.c_str()))
     {
     return -3;
     }
 
   // set the default BACKWARDS compatibility to the current version
-  if(!m_CacheManager->GetCacheValue("CMAKE_BACKWARDS_COMPATIBILITY"))
+  if(!this->CacheManager->GetCacheValue("CMAKE_BACKWARDS_COMPATIBILITY"))
     {
     char ver[256];
     sprintf(ver,"%i.%i",cmMakefile::GetMajorVersion(),
             cmMakefile::GetMinorVersion());
-    this->m_CacheManager->AddCacheEntry
-      ("CMAKE_BACKWARDS_COMPATIBILITY",ver,
+    this->CacheManager->AddCacheEntry
+      ("CMAKE_BACKWARDS_COMPATIBILITY",ver, 
        "For backwards compatibility, what version of CMake commands and "
        "syntax should this version of CMake allow.",
        cmCacheManager::STRING);
@@ -1726,17 +1730,17 @@ int cmake::LoadCache()
   return 0;
 }
 
-void cmake::SetProgressCallback(ProgressCallback f, void *cd)
+void cmake::SetProgressCallback(ProgressCallbackType f, void *cd)
 {
-  m_ProgressCallback = f;
-  m_ProgressCallbackClientData = cd;
+  this->ProgressCallback = f;
+  this->ProgressCallbackClientData = cd;
 }
 
 void cmake::UpdateProgress(const char *msg, float prog)
 {
-  if(m_ProgressCallback && !m_InTryCompile)
+  if(this->ProgressCallback && !this->InTryCompile)
     {
-    (*m_ProgressCallback)(msg, prog, m_ProgressCallbackClientData);
+    (*this->ProgressCallback)(msg, prog, this->ProgressCallbackClientData);
     return;
     }
 }
@@ -1744,8 +1748,8 @@ void cmake::UpdateProgress(const char *msg, float prog)
 void cmake::GetCommandDocumentation(
   std::vector<cmDocumentationEntry>& v) const
 {
-  for(RegisteredCommandsMap::const_iterator j = m_Commands.begin();
-      j != m_Commands.end(); ++j)
+  for(RegisteredCommandsMap::const_iterator j = this->Commands.begin();
+      j != this->Commands.end(); ++j)
     {
     cmDocumentationEntry e =
       {
@@ -1761,8 +1765,8 @@ void cmake::GetCommandDocumentation(
 
 void cmake::GetGeneratorDocumentation(std::vector<cmDocumentationEntry>& v)
 {
-  for(RegisteredGeneratorsMap::const_iterator i = m_Generators.begin();
-      i != m_Generators.end(); ++i)
+  for(RegisteredGeneratorsMap::const_iterator i = this->Generators.begin();
+      i != this->Generators.end(); ++i)
     {
     cmDocumentationEntry e;
     cmGlobalGenerator* generator = (i->second)();
@@ -1776,24 +1780,24 @@ void cmake::GetGeneratorDocumentation(std::vector<cmDocumentationEntry>& v)
 
 void cmake::AddWrittenFile(const char* file)
 {
-  m_WrittenFiles.insert(file);
+  this->WrittenFiles.insert(file);
 }
 
 bool cmake::HasWrittenFile(const char* file)
 {
-  return m_WrittenFiles.find(file) != m_WrittenFiles.end();
+  return this->WrittenFiles.find(file) != this->WrittenFiles.end();
 }
 
 void cmake::CleanupWrittenFiles()
 {
-  m_WrittenFiles.clear();
+  this->WrittenFiles.clear();
 }
 
 void cmake::UpdateConversionPathTable()
 {
   // Update the path conversion table with any specified file:
-  const char* tablepath =
-    m_CacheManager->GetCacheValue("CMAKE_PATH_TRANSLATION_FILE");
+  const char* tablepath = 
+    this->CacheManager->GetCacheValue("CMAKE_PATH_TRANSLATION_FILE");
 
   if(tablepath)
     {
@@ -1827,13 +1831,13 @@ int cmake::CheckBuildSystem()
   // does not then we need to check the integrity here.
 
   // If no file is provided for the check, we have to rerun.
-  if(m_CheckBuildSystem.size() == 0)
+  if(this->CheckBuildSystemArgument.size() == 0)
     {
     return 1;
     }
 
   // If the file provided does not exist, we have to rerun.
-  if(!cmSystemTools::FileExists(m_CheckBuildSystem.c_str()))
+  if(!cmSystemTools::FileExists(this->CheckBuildSystemArgument.c_str()))
     {
     return 1;
     }
@@ -1846,7 +1850,7 @@ int cmake::CheckBuildSystem()
   std::auto_ptr<cmLocalGenerator> lg(gg.CreateLocalGenerator());
   lg->SetGlobalGenerator(&gg);
   cmMakefile* mf = lg->GetMakefile();
-  if(!mf->ReadListFile(0, m_CheckBuildSystem.c_str()) ||
+  if(!mf->ReadListFile(0, this->CheckBuildSystemArgument.c_str()) ||
      cmSystemTools::GetErrorOccuredFlag())
     {
     // There was an error reading the file.  Just rerun.
@@ -1874,8 +1878,8 @@ int cmake::CheckBuildSystem()
         out != outputs.end(); ++out)
       {
       int result = 0;
-      if(!m_FileComparison->FileTimeCompare(out->c_str(),
-                                            dep->c_str(), &result) ||
+      if(!this->FileComparison->FileTimeCompare(out->c_str(), 
+                                                dep->c_str(), &result) ||
          result < 0)
         {
         return 1;
@@ -1899,7 +1903,7 @@ int cmake::CheckBuildSystem()
     {
     std::auto_ptr<cmLocalGenerator> lgd(ggd->CreateLocalGenerator());
     lgd->SetGlobalGenerator(ggd);
-    lgd->CheckDependencies(mf, verbose, m_ClearBuildSystem);
+    lgd->CheckDependencies(mf, verbose, this->ClearBuildSystem);
     }
 
   // No need to rerun.
@@ -1917,7 +1921,7 @@ void cmake::TruncateOutputLog(const char* fname)
     {
     return;
     }
-  if ( !m_CacheManager->GetCacheValue("CMAKE_CACHEFILE_DIR") )
+  if ( !this->CacheManager->GetCacheValue("CMAKE_CACHEFILE_DIR") )
     {
     cmSystemTools::RemoveFile(fullPath.c_str());
     return;
@@ -1942,95 +1946,95 @@ inline std::string removeQuotes(const std::string& s)
 
 const char* cmake::GetCTestCommand()
 {
-  if ( !m_CTestCommand.empty() )
+  if ( !this->CTestCommand.empty() )
     {
-    return m_CTestCommand.c_str();
+    return this->CTestCommand.c_str();
     }
 
   cmMakefile* mf
     = this->GetGlobalGenerator()->GetLocalGenerator(0)->GetMakefile();
 #ifdef CMAKE_BUILD_WITH_CMAKE
-  m_CTestCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
-  m_CTestCommand = removeQuotes(m_CTestCommand);
-  m_CTestCommand = cmSystemTools::GetFilenamePath(m_CTestCommand.c_str());
-  m_CTestCommand += "/";
-  m_CTestCommand += "ctest";
-  m_CTestCommand += cmSystemTools::GetExecutableExtension();
-  if(!cmSystemTools::FileExists(m_CTestCommand.c_str()))
-    {
-    m_CTestCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
-    m_CTestCommand = cmSystemTools::GetFilenamePath(m_CTestCommand.c_str());
-    m_CTestCommand += "/Debug/";
-    m_CTestCommand += "ctest";
-    m_CTestCommand += cmSystemTools::GetExecutableExtension();
-    }
-  if(!cmSystemTools::FileExists(m_CTestCommand.c_str()))
-    {
-    m_CTestCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
-    m_CTestCommand = cmSystemTools::GetFilenamePath(m_CTestCommand.c_str());
-    m_CTestCommand += "/Release/";
-    m_CTestCommand += "ctest";
-    m_CTestCommand += cmSystemTools::GetExecutableExtension();
+  this->CTestCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
+  this->CTestCommand = removeQuotes(this->CTestCommand);
+  this->CTestCommand = cmSystemTools::GetFilenamePath(this->CTestCommand.c_str());
+  this->CTestCommand += "/";
+  this->CTestCommand += "ctest";
+  this->CTestCommand += cmSystemTools::GetExecutableExtension();
+  if(!cmSystemTools::FileExists(this->CTestCommand.c_str()))
+    {
+    this->CTestCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
+    this->CTestCommand = cmSystemTools::GetFilenamePath(this->CTestCommand.c_str());
+    this->CTestCommand += "/Debug/";
+    this->CTestCommand += "ctest";
+    this->CTestCommand += cmSystemTools::GetExecutableExtension();
+    }
+  if(!cmSystemTools::FileExists(this->CTestCommand.c_str()))
+    {
+    this->CTestCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
+    this->CTestCommand = cmSystemTools::GetFilenamePath(this->CTestCommand.c_str());
+    this->CTestCommand += "/Release/";
+    this->CTestCommand += "ctest";
+    this->CTestCommand += cmSystemTools::GetExecutableExtension();
     }
 #else
   // Only for bootstrap
-  m_CTestCommand += mf->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
-  m_CTestCommand += "/ctest";
-  m_CTestCommand += cmSystemTools::GetExecutableExtension();
+  this->CTestCommand += mf->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
+  this->CTestCommand += "/ctest";
+  this->CTestCommand += cmSystemTools::GetExecutableExtension();
 #endif
-  if ( m_CTestCommand.empty() )
+  if ( this->CTestCommand.empty() )
     {
     cmSystemTools::Error("Cannot find the CTest executable");
-    m_CTestCommand = "CTEST-COMMAND-NOT-FOUND";
+    this->CTestCommand = "CTEST-COMMAND-NOT-FOUND";
     }
-  return m_CTestCommand.c_str();
+  return this->CTestCommand.c_str();
 }
 
 const char* cmake::GetCPackCommand()
 {
-  if ( !m_CPackCommand.empty() )
+  if ( !this->CPackCommand.empty() )
     {
-    return m_CPackCommand.c_str();
+    return this->CPackCommand.c_str();
     }
 
   cmMakefile* mf
     = this->GetGlobalGenerator()->GetLocalGenerator(0)->GetMakefile();
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
-  m_CPackCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
-  m_CPackCommand = removeQuotes(m_CPackCommand);
-  m_CPackCommand = cmSystemTools::GetFilenamePath(m_CPackCommand.c_str());
-  m_CPackCommand += "/";
-  m_CPackCommand += "cpack";
-  m_CPackCommand += cmSystemTools::GetExecutableExtension();
-  if(!cmSystemTools::FileExists(m_CPackCommand.c_str()))
-    {
-    m_CPackCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
-    m_CPackCommand = cmSystemTools::GetFilenamePath(m_CPackCommand.c_str());
-    m_CPackCommand += "/Debug/";
-    m_CPackCommand += "cpack";
-    m_CPackCommand += cmSystemTools::GetExecutableExtension();
-    }
-  if(!cmSystemTools::FileExists(m_CPackCommand.c_str()))
-    {
-    m_CPackCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
-    m_CPackCommand = cmSystemTools::GetFilenamePath(m_CPackCommand.c_str());
-    m_CPackCommand += "/Release/";
-    m_CPackCommand += "cpack";
-    m_CPackCommand += cmSystemTools::GetExecutableExtension();
-    }
-  if (!cmSystemTools::FileExists(m_CPackCommand.c_str()))
+  this->CPackCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
+  this->CPackCommand = removeQuotes(this->CPackCommand);
+  this->CPackCommand = cmSystemTools::GetFilenamePath(this->CPackCommand.c_str());
+  this->CPackCommand += "/";
+  this->CPackCommand += "cpack";
+  this->CPackCommand += cmSystemTools::GetExecutableExtension();
+  if(!cmSystemTools::FileExists(this->CPackCommand.c_str()))
+    {
+    this->CPackCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
+    this->CPackCommand = cmSystemTools::GetFilenamePath(this->CPackCommand.c_str());
+    this->CPackCommand += "/Debug/";
+    this->CPackCommand += "cpack";
+    this->CPackCommand += cmSystemTools::GetExecutableExtension();
+    }
+  if(!cmSystemTools::FileExists(this->CPackCommand.c_str()))
+    {
+    this->CPackCommand = mf->GetRequiredDefinition("CMAKE_COMMAND");
+    this->CPackCommand = cmSystemTools::GetFilenamePath(this->CPackCommand.c_str());
+    this->CPackCommand += "/Release/";
+    this->CPackCommand += "cpack";
+    this->CPackCommand += cmSystemTools::GetExecutableExtension();
+    }
+  if (!cmSystemTools::FileExists(this->CPackCommand.c_str()))
     {
     cmSystemTools::Error("Cannot find the CPack executable");
-    m_CPackCommand = "CPACK-COMMAND-NOT-FOUND";
+    this->CPackCommand = "CPACK-COMMAND-NOT-FOUND";
     }
 #else
   // Only for bootstrap
-  m_CPackCommand += mf->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
-  m_CPackCommand += "/cpack";
-  m_CPackCommand += cmSystemTools::GetExecutableExtension();
+  this->CPackCommand += mf->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
+  this->CPackCommand += "/cpack";
+  this->CPackCommand += cmSystemTools::GetExecutableExtension();
 #endif
-  return m_CPackCommand.c_str();
+  return this->CPackCommand.c_str();
 }
 
 void cmake::GenerateGraphViz(const char* fileName)
@@ -2141,9 +2145,9 @@ void cmake::GenerateGraphViz(const char* fileName)
     cmTargets::iterator tit;
     for ( tit = targets->begin(); tit != targets->end(); ++ tit )
       {
-      const cmTarget::LinkLibraries* ll
+      const cmTarget::LinkLibraryVectorType* ll
         = &(tit->second.GetOriginalLinkLibraries());
-      cmTarget::LinkLibraries::const_iterator llit;
+      cmTarget::LinkLibraryVectorType::const_iterator llit;
       const char* realTargetName = tit->first.c_str();
       if ( ignoreTargetsSet.find(realTargetName) != ignoreTargetsSet.end() )
         {
@@ -2254,9 +2258,9 @@ void cmake::GenerateGraphViz(const char* fileName)
         }
       std::map<cmStdString, cmStdString>::iterator cmakeTarIt
         = targetNamesNodes.find(tit->first.c_str());
-      const cmTarget::LinkLibraries* ll
+      const cmTarget::LinkLibraryVectorType* ll
         = &(tit->second.GetOriginalLinkLibraries());
-      cmTarget::LinkLibraries::const_iterator llit;
+      cmTarget::LinkLibraryVectorType::const_iterator llit;
       for ( llit = ll->begin(); llit != ll->end(); ++ llit )
         {
         const char* libName = llit->first.c_str();
diff --git a/Source/cmake.h b/Source/cmake.h
index 6911588..ca3e0bc 100644
--- a/Source/cmake.h
+++ b/Source/cmake.h
@@ -78,12 +78,12 @@ class cmake
   void SetHomeDirectory(const char* dir);
   const char* GetHomeDirectory() const
     {
-    return m_cmHomeDirectory.c_str();
+    return this->cmHomeDirectory.c_str();
     }
   void SetHomeOutputDirectory(const char* lib);
   const char* GetHomeOutputDirectory() const
     {
-    return m_HomeOutputDirectory.c_str();
+    return this->HomeOutputDirectory.c_str();
     }
   //@}
 
@@ -97,21 +97,21 @@ class cmake
    */
   void SetStartDirectory(const char* dir) 
     {
-      m_cmStartDirectory = dir;
-      cmSystemTools::ConvertToUnixSlashes(m_cmStartDirectory);
+      this->cmStartDirectory = dir;
+      cmSystemTools::ConvertToUnixSlashes(this->cmStartDirectory);
     }
   const char* GetStartDirectory() const
     {
-      return m_cmStartDirectory.c_str();
+      return this->cmStartDirectory.c_str();
     }
   void SetStartOutputDirectory(const char* lib)
     {
-      m_StartOutputDirectory = lib;
-      cmSystemTools::ConvertToUnixSlashes(m_StartOutputDirectory);
+      this->StartOutputDirectory = lib;
+      cmSystemTools::ConvertToUnixSlashes(this->StartOutputDirectory);
     }
   const char* GetStartOutputDirectory() const
     {
-      return m_StartOutputDirectory.c_str();
+      return this->StartOutputDirectory.c_str();
     }
   //@}
 
@@ -161,7 +161,7 @@ class cmake
   cmGlobalGenerator* CreateGlobalGenerator(const char* name);
 
   ///! Return the global generator assigned to this instance of cmake
-  cmGlobalGenerator* GetGlobalGenerator() { return m_GlobalGenerator; };
+  cmGlobalGenerator* GetGlobalGenerator() { return this->GlobalGenerator; };
 
   ///! Return the global generator assigned to this instance of cmake
   void SetGlobalGenerator(cmGlobalGenerator *);
@@ -170,10 +170,10 @@ class cmake
   void GetRegisteredGenerators(std::vector<std::string>& names);
 
   ///! get the cmCachemManager used by this invocation of cmake
-  cmCacheManager *GetCacheManager() { return m_CacheManager; }
+  cmCacheManager *GetCacheManager() { return this->CacheManager; }
   
   ///! set the cmake command this instance of cmake should use
-  void SetCMakeCommand(const char* cmd) { m_CMakeCommand = cmd; }
+  void SetCMakeCommand(const char* cmd) { this->CMakeCommand = cmd; }
   
   /**
    * Given a variable name, return its value (as a string).
@@ -187,7 +187,7 @@ class cmake
    * Execute commands during the build process. Supports options such
    * as echo, remove file etc.
    */
-  static int CMakeCommand(std::vector<std::string>&);
+  static int ExecuteCMakeCommand(std::vector<std::string>&);
 
   /**
    * Add a command to this cmake instance
@@ -201,7 +201,7 @@ class cmake
   cmCommand *GetCommand(const char *name);
 
   /** Get list of all commands */
-  RegisteredCommandsMap* GetCommands() { return &m_Commands; }
+  RegisteredCommandsMap* GetCommands() { return &this->Commands; }
 
   /** Check if a command exists. */
   bool CommandExists(const char* name) const;
@@ -210,15 +210,16 @@ class cmake
   void SetArgs(const std::vector<std::string>&);
 
   ///! Is this cmake running as a result of a TRY_COMPILE command
-  bool GetIsInTryCompile() { return m_InTryCompile; }
+  bool GetIsInTryCompile() { return this->InTryCompile; }
   
   ///! Is this cmake running as a result of a TRY_COMPILE command
-  void SetIsInTryCompile(bool i) { m_InTryCompile = i; }
+  void SetIsInTryCompile(bool i) { this->InTryCompile = i; }
   
   ///! Parse command line arguments that might set cache values
   bool SetCacheArgs(const std::vector<std::string>&);
 
-  typedef  void (*ProgressCallback)(const char*msg, float progress, void *);
+  typedef  void (*ProgressCallbackType)
+    (const char*msg, float progress, void *);
   /**
    *  Set the function used by GUI's to receive progress updates
    *  Function gets passed: message as a const char*, a progress 
@@ -226,14 +227,14 @@ class cmake
    *  number provided may be negative in cases where a message is 
    *  to be displayed without any progress percentage.
    */
-  void SetProgressCallback(ProgressCallback f, void* clientData=0);
+  void SetProgressCallback(ProgressCallbackType f, void* clientData=0);
 
   ///! this is called by generators to update the progress
   void UpdateProgress(const char *msg, float prog);
 
 
   ///! Get the variable watch object
-  cmVariableWatch* GetVariableWatch() { return m_VariableWatch; }
+  cmVariableWatch* GetVariableWatch() { return this->VariableWatch; }
 
   void GetCommandDocumentation(std::vector<cmDocumentationEntry>&) const;
   void GetGeneratorDocumentation(std::vector<cmDocumentationEntry>&);
@@ -246,12 +247,12 @@ class cmake
    * and no cache. Also, language are not enabled, so add_executable and things
    * do not do anything.
    */
-  void SetScriptMode(bool mode) { m_ScriptMode = mode; }
-  bool GetScriptMode() { return m_ScriptMode; }
+  void SetScriptMode(bool mode) { this->ScriptMode = mode; }
+  bool GetScriptMode() { return this->ScriptMode; }
   
   ///! Debug the try compile stuff by not delelting the files
-  bool GetDebugTryCompile(){return m_DebugTryCompile;}
-  void DebugTryCompileOn(){m_DebugTryCompile = true;}
+  bool GetDebugTryCompile(){return this->DebugTryCompile;}
+  void DebugTryCompileOn(){this->DebugTryCompile = true;}
 
   ///! Get the list of files written by CMake using FILE(WRITE / WRITE_FILE
   void AddWrittenFile(const char* file);
@@ -266,32 +267,32 @@ class cmake
   /**
    * Get the file comparison class
    */
-  cmFileTimeComparison* GetFileComparison() { return m_FileComparison; }
+  cmFileTimeComparison* GetFileComparison() { return this->FileComparison; }
 
   /**
    * Get the path to ctest
    */
   const char* GetCTestCommand();
   const char* GetCPackCommand();
-  const char* GetCMakeCommand() { return m_CMakeCommand.c_str(); }
+  const char* GetCMakeCommand() { return this->CMakeCommand.c_str(); }
 
 protected:
   typedef cmGlobalGenerator* (*CreateGeneratorFunctionType)();
   typedef std::map<cmStdString,
                    CreateGeneratorFunctionType> RegisteredGeneratorsMap;
-  RegisteredCommandsMap m_Commands;
-  RegisteredGeneratorsMap m_Generators;
+  RegisteredCommandsMap Commands;
+  RegisteredGeneratorsMap Generators;
   void AddDefaultCommands();
   void AddDefaultGenerators();
 
-  cmGlobalGenerator *m_GlobalGenerator;
-  cmCacheManager *m_CacheManager;
-  std::string m_cmHomeDirectory; 
-  std::string m_HomeOutputDirectory;
-  std::string m_cmStartDirectory; 
-  std::string m_StartOutputDirectory;
+  cmGlobalGenerator *GlobalGenerator;
+  cmCacheManager *CacheManager;
+  std::string cmHomeDirectory; 
+  std::string HomeOutputDirectory;
+  std::string cmStartDirectory; 
+  std::string StartOutputDirectory;
 
-  std::set<cmStdString> m_WrittenFiles;
+  std::set<cmStdString> WrittenFiles;
 
   ///! return true if the same cmake was used to make the cache.
   bool CacheVersionMatches();
@@ -315,24 +316,24 @@ protected:
 
   void GenerateGraphViz(const char* fileName);
   
-  cmVariableWatch* m_VariableWatch;
+  cmVariableWatch* VariableWatch;
 
 private:
-  ProgressCallback m_ProgressCallback;
-  void* m_ProgressCallbackClientData;
-  bool m_Verbose;
-  bool m_InTryCompile;
-  bool m_ScriptMode;
-  std::string m_CMakeCommand;
-  std::string m_CXXEnvironment;
-  std::string m_CCEnvironment;
-  std::string m_CheckBuildSystem;
-  std::string m_CTestCommand;
-  std::string m_CPackCommand;
-  bool m_ClearBuildSystem;
-  bool m_DebugTryCompile;
-  cmFileTimeComparison* m_FileComparison;
-  std::string m_GraphVizFile;
+  ProgressCallbackType ProgressCallback;
+  void* ProgressCallbackClientData;
+  bool Verbose;
+  bool InTryCompile;
+  bool ScriptMode;
+  std::string CMakeCommand;
+  std::string CXXEnvironment;
+  std::string CCEnvironment;
+  std::string CheckBuildSystemArgument;
+  std::string CTestCommand;
+  std::string CPackCommand;
+  bool ClearBuildSystem;
+  bool DebugTryCompile;
+  cmFileTimeComparison* FileComparison;
+  std::string GraphVizFile;
   
   void UpdateConversionPathTable();
 };
diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx
index cc8e80d..8c8c013 100644
--- a/Source/cmakemain.cxx
+++ b/Source/cmakemain.cxx
@@ -243,7 +243,7 @@ int do_cmake(int ac, char** av)
 
   if(command)
     {
-    int ret = cmake::CMakeCommand(args);
+    int ret = cmake::ExecuteCMakeCommand(args);
     return ret;
     }
   if (wiz)
diff --git a/Source/cmakewizard.cxx b/Source/cmakewizard.cxx
index 79f4a95..702909e 100644
--- a/Source/cmakewizard.cxx
+++ b/Source/cmakewizard.cxx
@@ -20,7 +20,7 @@
 
 cmakewizard::cmakewizard()
 {
-  m_ShowAdvanced = false;
+  this->ShowAdvanced = false;
 }
 
 
@@ -92,7 +92,7 @@ void cmakewizard::ShowMessage(const char* m)
 
 int cmakewizard::RunWizard(std::vector<std::string> const& args)
 {
-  m_ShowAdvanced = this->AskAdvanced();
+  this->ShowAdvanced = this->AskAdvanced();
   cmSystemTools::DisableRunCommandOutput();
   cmake make;
   make.SetArgs(args);
@@ -130,7 +130,7 @@ int cmakewizard::RunWizard(std::vector<std::string> const& args)
         std::string& e = askedCache.find(key)->second;
         if(e != i.GetValue())
           {
-          if(m_ShowAdvanced || !i.GetPropertyAsBool("ADVANCED"))
+          if(this->ShowAdvanced || !i.GetPropertyAsBool("ADVANCED"))
             {
             this->AskUser(key.c_str(), i);
             asked = true;
@@ -138,8 +138,8 @@ int cmakewizard::RunWizard(std::vector<std::string> const& args)
           }
         }
       else
-        {
-        if(m_ShowAdvanced || !i.GetPropertyAsBool("ADVANCED"))
+        {    
+        if(this->ShowAdvanced || !i.GetPropertyAsBool("ADVANCED"))
           {
           this->AskUser(key.c_str(), i);
           asked = true;
diff --git a/Source/cmakewizard.h b/Source/cmakewizard.h
index ec79c52..97ee4d3 100644
--- a/Source/cmakewizard.h
+++ b/Source/cmakewizard.h
@@ -42,6 +42,6 @@ public:
   int RunWizard(std::vector<std::string>const& args);
   
 private:
-  bool m_ShowAdvanced;
+  bool ShowAdvanced;
 };