mark functions with CM_OVERRIDE

216 files changed, 1125 insertions, 1034 deletions

diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.h b/Source/CPack/IFW/cmCPackIFWGenerator.h
index 2b35749..12f2ca6 100644
--- a/Source/CPack/IFW/cmCPackIFWGenerator.h
+++ b/Source/CPack/IFW/cmCPackIFWGenerator.h
@@ -46,7 +46,7 @@ public:
   /**
    * Destruct IFW generator
    */
-  virtual ~cmCPackIFWGenerator();
+  ~cmCPackIFWGenerator() CM_OVERRIDE;
 
   /**
    * Compare \a version with QtIFW framework version
@@ -70,18 +70,18 @@ protected:
    * @brief Initialize generator
    * @return 0 on failure
    */
-  virtual int InitializeInternal();
-  virtual int PackageFiles();
-  virtual const char* GetPackagingInstallPrefix();
+  int InitializeInternal() CM_OVERRIDE;
+  int PackageFiles() CM_OVERRIDE;
+  const char* GetPackagingInstallPrefix() CM_OVERRIDE;
 
   /**
    * @brief Extension of binary installer
    * @return Executable suffix or value from default implementation
    */
-  virtual const char* GetOutputExtension();
+  const char* GetOutputExtension() CM_OVERRIDE;
 
-  virtual std::string GetComponentInstallDirNameSuffix(
-    const std::string& componentName);
+  std::string GetComponentInstallDirNameSuffix(
+    const std::string& componentName) CM_OVERRIDE;
 
   /**
    * @brief Get Component
@@ -92,8 +92,8 @@ protected:
    *
    * @return Pointer to component
    */
-  virtual cmCPackComponent* GetComponent(const std::string& projectName,
-                                         const std::string& componentName);
+  cmCPackComponent* GetComponent(const std::string& projectName,
+                                 const std::string& componentName) CM_OVERRIDE;
 
   /**
    * @brief Get group of component
@@ -104,12 +104,13 @@ protected:
    *
    * @return Pointer to component group
    */
-  virtual cmCPackComponentGroup* GetComponentGroup(
-    const std::string& projectName, const std::string& groupName);
+  cmCPackComponentGroup* GetComponentGroup(
+    const std::string& projectName, const std::string& groupName) CM_OVERRIDE;
 
-  enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const;
-  virtual bool SupportsAbsoluteDestination() const;
-  virtual bool SupportsComponentInstallation() const;
+  enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const
+    CM_OVERRIDE;
+  bool SupportsAbsoluteDestination() const CM_OVERRIDE;
+  bool SupportsComponentInstallation() const CM_OVERRIDE;
 
 protected:
   // Methods
diff --git a/Source/CPack/cmCPack7zGenerator.h b/Source/CPack/cmCPack7zGenerator.h
index f5a323f..ddbcc34 100644
--- a/Source/CPack/cmCPack7zGenerator.h
+++ b/Source/CPack/cmCPack7zGenerator.h
@@ -27,10 +27,10 @@ public:
    * Construct generator
    */
   cmCPack7zGenerator();
-  virtual ~cmCPack7zGenerator();
+  ~cmCPack7zGenerator() CM_OVERRIDE;
 
 protected:
-  virtual const char* GetOutputExtension() { return ".7z"; }
+  const char* GetOutputExtension() CM_OVERRIDE { return ".7z"; }
 };
 
 #endif
diff --git a/Source/CPack/cmCPackArchiveGenerator.h b/Source/CPack/cmCPackArchiveGenerator.h
index 9eb38b1..a018ebd 100644
--- a/Source/CPack/cmCPackArchiveGenerator.h
+++ b/Source/CPack/cmCPackArchiveGenerator.h
@@ -32,14 +32,14 @@ public:
    * Construct generator
    */
   cmCPackArchiveGenerator(cmArchiveWrite::Compress, std::string const& format);
-  virtual ~cmCPackArchiveGenerator();
+  ~cmCPackArchiveGenerator() CM_OVERRIDE;
   // Used to add a header to the archive
   virtual int GenerateHeader(std::ostream* os);
   // component support
-  virtual bool SupportsComponentInstallation() const;
+  bool SupportsComponentInstallation() const CM_OVERRIDE;
 
 protected:
-  virtual int InitializeInternal();
+  int InitializeInternal() CM_OVERRIDE;
   /**
    * Add the files belonging to the specified component
    * to the provided (already opened) archive.
@@ -55,7 +55,7 @@ protected:
    * method will call either PackageComponents or
    * PackageComponentsAllInOne.
    */
-  int PackageFiles();
+  int PackageFiles() CM_OVERRIDE;
   /**
    * The method used to package files when component
    * install is used. This will create one
@@ -67,7 +67,7 @@ protected:
    * components will be put in a single installer.
    */
   int PackageComponentsAllInOne();
-  virtual const char* GetOutputExtension() = 0;
+  const char* GetOutputExtension() CM_OVERRIDE = 0;
   cmArchiveWrite::Compress Compress;
   std::string ArchiveFormat;
 };
diff --git a/Source/CPack/cmCPackDebGenerator.h b/Source/CPack/cmCPackDebGenerator.h
index ff34ca5..bcdc509 100644
--- a/Source/CPack/cmCPackDebGenerator.h
+++ b/Source/CPack/cmCPackDebGenerator.h
@@ -28,7 +28,7 @@ public:
    * Construct generator
    */
   cmCPackDebGenerator();
-  virtual ~cmCPackDebGenerator();
+  ~cmCPackDebGenerator() CM_OVERRIDE;
 
   static bool CanGenerate()
   {
@@ -45,7 +45,7 @@ public:
   }
 
 protected:
-  virtual int InitializeInternal();
+  int InitializeInternal() CM_OVERRIDE;
   /**
    * This method factors out the work done in component packaging case.
    */
@@ -62,11 +62,11 @@ protected:
    * components will be put in a single installer.
    */
   int PackageComponentsAllInOne(const std::string& compInstDirName);
-  virtual int PackageFiles();
-  virtual const char* GetOutputExtension() { return ".deb"; }
-  virtual bool SupportsComponentInstallation() const;
-  virtual std::string GetComponentInstallDirNameSuffix(
-    const std::string& componentName);
+  int PackageFiles() CM_OVERRIDE;
+  const char* GetOutputExtension() CM_OVERRIDE { return ".deb"; }
+  bool SupportsComponentInstallation() const CM_OVERRIDE;
+  std::string GetComponentInstallDirNameSuffix(
+    const std::string& componentName) CM_OVERRIDE;
 
 private:
   int createDeb();
diff --git a/Source/CPack/cmCPackGenerator.h b/Source/CPack/cmCPackGenerator.h
index ce93715..6313a0e 100644
--- a/Source/CPack/cmCPackGenerator.h
+++ b/Source/CPack/cmCPackGenerator.h
@@ -101,7 +101,7 @@ public:
    * Construct generator
    */
   cmCPackGenerator();
-  virtual ~cmCPackGenerator();
+  ~cmCPackGenerator() CM_OVERRIDE;
 
   //! Set and get the options
   void SetOption(const std::string& op, const char* value);
diff --git a/Source/CPack/cmCPackGeneratorFactory.h b/Source/CPack/cmCPackGeneratorFactory.h
index a55ec6e..f0ed57a 100644
--- a/Source/CPack/cmCPackGeneratorFactory.h
+++ b/Source/CPack/cmCPackGeneratorFactory.h
@@ -28,7 +28,7 @@ public:
   cmTypeMacro(cmCPackGeneratorFactory, cmObject);
 
   cmCPackGeneratorFactory();
-  ~cmCPackGeneratorFactory();
+  ~cmCPackGeneratorFactory() CM_OVERRIDE;
 
   //! Get the generator
   cmCPackGenerator* NewGenerator(const std::string& name);
diff --git a/Source/CPack/cmCPackLog.h b/Source/CPack/cmCPackLog.h
index 41871cc..77f0f0b 100644
--- a/Source/CPack/cmCPackLog.h
+++ b/Source/CPack/cmCPackLog.h
@@ -42,7 +42,7 @@ public:
   cmTypeMacro(cmCPackLog, cmObject);
 
   cmCPackLog();
-  ~cmCPackLog();
+  ~cmCPackLog() CM_OVERRIDE;
 
   enum __log_tags
   {
diff --git a/Source/CPack/cmCPackNSISGenerator.h b/Source/CPack/cmCPackNSISGenerator.h
index ae3ccca..4923cf0 100644
--- a/Source/CPack/cmCPackNSISGenerator.h
+++ b/Source/CPack/cmCPackNSISGenerator.h
@@ -36,21 +36,22 @@ public:
    * Construct generator
    */
   cmCPackNSISGenerator(bool nsis64 = false);
-  virtual ~cmCPackNSISGenerator();
+  ~cmCPackNSISGenerator() CM_OVERRIDE;
 
 protected:
-  virtual int InitializeInternal();
+  int InitializeInternal() CM_OVERRIDE;
   void CreateMenuLinks(std::ostream& str, std::ostream& deleteStr);
-  int PackageFiles();
-  virtual const char* GetOutputExtension() { return ".exe"; }
-  virtual const char* GetOutputPostfix() { return "win32"; }
+  int PackageFiles() CM_OVERRIDE;
+  const char* GetOutputExtension() CM_OVERRIDE { return ".exe"; }
+  const char* GetOutputPostfix() CM_OVERRIDE { return "win32"; }
 
   bool GetListOfSubdirectories(const char* dir,
                                std::vector<std::string>& dirs);
 
-  enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const;
-  virtual bool SupportsAbsoluteDestination() const;
-  virtual bool SupportsComponentInstallation() const;
+  enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const
+    CM_OVERRIDE;
+  bool SupportsAbsoluteDestination() const CM_OVERRIDE;
+  bool SupportsComponentInstallation() const CM_OVERRIDE;
 
   /// Produce a string that contains the NSIS code to describe a
   /// particular component. Any added macros will be emitted via
diff --git a/Source/CPack/cmCPackRPMGenerator.h b/Source/CPack/cmCPackRPMGenerator.h
index b39f2c2..4baef08 100644
--- a/Source/CPack/cmCPackRPMGenerator.h
+++ b/Source/CPack/cmCPackRPMGenerator.h
@@ -32,7 +32,7 @@ public:
    * Construct generator
    */
   cmCPackRPMGenerator();
-  virtual ~cmCPackRPMGenerator();
+  ~cmCPackRPMGenerator() CM_OVERRIDE;
 
   static bool CanGenerate()
   {
@@ -49,8 +49,8 @@ public:
   }
 
 protected:
-  virtual int InitializeInternal();
-  virtual int PackageFiles();
+  int InitializeInternal() CM_OVERRIDE;
+  int PackageFiles() CM_OVERRIDE;
   /**
    * This method factors out the work done in component packaging case.
    */
@@ -67,10 +67,10 @@ protected:
    * components will be put in a single installer.
    */
   int PackageComponentsAllInOne(const std::string& compInstDirName);
-  virtual const char* GetOutputExtension() { return ".rpm"; }
-  virtual bool SupportsComponentInstallation() const;
-  virtual std::string GetComponentInstallDirNameSuffix(
-    const std::string& componentName);
+  const char* GetOutputExtension() CM_OVERRIDE { return ".rpm"; }
+  bool SupportsComponentInstallation() const CM_OVERRIDE;
+  std::string GetComponentInstallDirNameSuffix(
+    const std::string& componentName) CM_OVERRIDE;
 
   void AddGeneratedPackageNames();
 };
diff --git a/Source/CPack/cmCPackSTGZGenerator.h b/Source/CPack/cmCPackSTGZGenerator.h
index 08152b5..94cc8aa 100644
--- a/Source/CPack/cmCPackSTGZGenerator.h
+++ b/Source/CPack/cmCPackSTGZGenerator.h
@@ -28,13 +28,13 @@ public:
    * Construct generator
    */
   cmCPackSTGZGenerator();
-  virtual ~cmCPackSTGZGenerator();
+  ~cmCPackSTGZGenerator() CM_OVERRIDE;
 
 protected:
-  int PackageFiles();
-  virtual int InitializeInternal();
-  int GenerateHeader(std::ostream* os);
-  virtual const char* GetOutputExtension() { return ".sh"; }
+  int PackageFiles() CM_OVERRIDE;
+  int InitializeInternal() CM_OVERRIDE;
+  int GenerateHeader(std::ostream* os) CM_OVERRIDE;
+  const char* GetOutputExtension() CM_OVERRIDE { return ".sh"; }
 };
 
 #endif
diff --git a/Source/CPack/cmCPackTGZGenerator.h b/Source/CPack/cmCPackTGZGenerator.h
index 408422b..cb7620c 100644
--- a/Source/CPack/cmCPackTGZGenerator.h
+++ b/Source/CPack/cmCPackTGZGenerator.h
@@ -27,10 +27,10 @@ public:
    * Construct generator
    */
   cmCPackTGZGenerator();
-  virtual ~cmCPackTGZGenerator();
+  ~cmCPackTGZGenerator() CM_OVERRIDE;
 
 protected:
-  virtual const char* GetOutputExtension() { return ".tar.gz"; }
+  const char* GetOutputExtension() CM_OVERRIDE { return ".tar.gz"; }
 };
 
 #endif
diff --git a/Source/CPack/cmCPackTXZGenerator.h b/Source/CPack/cmCPackTXZGenerator.h
index 05052a1..87c92ef 100644
--- a/Source/CPack/cmCPackTXZGenerator.h
+++ b/Source/CPack/cmCPackTXZGenerator.h
@@ -27,10 +27,10 @@ public:
    * Construct generator
    */
   cmCPackTXZGenerator();
-  virtual ~cmCPackTXZGenerator();
+  ~cmCPackTXZGenerator() CM_OVERRIDE;
 
 protected:
-  virtual const char* GetOutputExtension() { return ".tar.xz"; }
+  const char* GetOutputExtension() CM_OVERRIDE { return ".tar.xz"; }
 };
 
 #endif
diff --git a/Source/CPack/cmCPackTarBZip2Generator.h b/Source/CPack/cmCPackTarBZip2Generator.h
index 4033197..6fec882 100644
--- a/Source/CPack/cmCPackTarBZip2Generator.h
+++ b/Source/CPack/cmCPackTarBZip2Generator.h
@@ -26,10 +26,10 @@ public:
    * Construct generator
    */
   cmCPackTarBZip2Generator();
-  virtual ~cmCPackTarBZip2Generator();
+  ~cmCPackTarBZip2Generator() CM_OVERRIDE;
 
 protected:
-  virtual const char* GetOutputExtension() { return ".tar.bz2"; }
+  const char* GetOutputExtension() CM_OVERRIDE { return ".tar.bz2"; }
 };
 
 #endif
diff --git a/Source/CPack/cmCPackTarCompressGenerator.h b/Source/CPack/cmCPackTarCompressGenerator.h
index 7ff9a0a..02926a2 100644
--- a/Source/CPack/cmCPackTarCompressGenerator.h
+++ b/Source/CPack/cmCPackTarCompressGenerator.h
@@ -26,10 +26,10 @@ public:
    * Construct generator
    */
   cmCPackTarCompressGenerator();
-  virtual ~cmCPackTarCompressGenerator();
+  ~cmCPackTarCompressGenerator() CM_OVERRIDE;
 
 protected:
-  virtual const char* GetOutputExtension() { return ".tar.Z"; }
+  const char* GetOutputExtension() CM_OVERRIDE { return ".tar.Z"; }
 };
 
 #endif
diff --git a/Source/CPack/cmCPackZIPGenerator.h b/Source/CPack/cmCPackZIPGenerator.h
index 70e1a5f..1130826 100644
--- a/Source/CPack/cmCPackZIPGenerator.h
+++ b/Source/CPack/cmCPackZIPGenerator.h
@@ -27,10 +27,10 @@ public:
    * Construct generator
    */
   cmCPackZIPGenerator();
-  virtual ~cmCPackZIPGenerator();
+  ~cmCPackZIPGenerator() CM_OVERRIDE;
 
 protected:
-  virtual const char* GetOutputExtension() { return ".zip"; }
+  const char* GetOutputExtension() CM_OVERRIDE { return ".zip"; }
 };
 
 #endif
diff --git a/Source/CTest/cmCTestBZR.cxx b/Source/CTest/cmCTestBZR.cxx
index 5b3f612..17d4eef 100644
--- a/Source/CTest/cmCTestBZR.cxx
+++ b/Source/CTest/cmCTestBZR.cxx
@@ -183,7 +183,7 @@ public:
   {
     this->InitializeParser();
   }
-  ~LogParser() { this->CleanupParser(); }
+  ~LogParser() CM_OVERRIDE { this->CleanupParser(); }
 
   int InitializeParser() CM_OVERRIDE
   {
diff --git a/Source/CTest/cmCTestBZR.h b/Source/CTest/cmCTestBZR.h
index 4f44136..0f05d38 100644
--- a/Source/CTest/cmCTestBZR.h
+++ b/Source/CTest/cmCTestBZR.h
@@ -24,20 +24,20 @@ public:
   /** Construct with a CTest instance and update log stream.  */
   cmCTestBZR(cmCTest* ctest, std::ostream& log);
 
-  virtual ~cmCTestBZR();
+  ~cmCTestBZR() CM_OVERRIDE;
 
 private:
   // Implement cmCTestVC internal API.
-  virtual void NoteOldRevision();
-  virtual void NoteNewRevision();
-  virtual bool UpdateImpl();
+  void NoteOldRevision() CM_OVERRIDE;
+  void NoteNewRevision() CM_OVERRIDE;
+  bool UpdateImpl() CM_OVERRIDE;
 
   // URL of repository directory checked out in the working tree.
   std::string URL;
 
   std::string LoadInfo();
-  void LoadModifications();
-  void LoadRevisions();
+  void LoadModifications() CM_OVERRIDE;
+  void LoadRevisions() CM_OVERRIDE;
 
   // Parsing helper classes.
   class InfoParser;
diff --git a/Source/CTest/cmCTestBatchTestHandler.h b/Source/CTest/cmCTestBatchTestHandler.h
index ed60ea3..17cc234 100644
--- a/Source/CTest/cmCTestBatchTestHandler.h
+++ b/Source/CTest/cmCTestBatchTestHandler.h
@@ -28,8 +28,8 @@
 class cmCTestBatchTestHandler : public cmCTestMultiProcessHandler
 {
 public:
-  ~cmCTestBatchTestHandler();
-  virtual void RunTests();
+  ~cmCTestBatchTestHandler() CM_OVERRIDE;
+  void RunTests() CM_OVERRIDE;
 
 protected:
   void WriteBatchScript();
diff --git a/Source/CTest/cmCTestBuildAndTestHandler.h b/Source/CTest/cmCTestBuildAndTestHandler.h
index d0443ae..2aa90a4 100644
--- a/Source/CTest/cmCTestBuildAndTestHandler.h
+++ b/Source/CTest/cmCTestBuildAndTestHandler.h
@@ -30,12 +30,12 @@ public:
   /*
    * The main entry point for this class
    */
-  int ProcessHandler();
+  int ProcessHandler() CM_OVERRIDE;
 
   //! Set all the build and test arguments
-  virtual int ProcessCommandLineArguments(
-    const std::string& currentArg, size_t& idx,
-    const std::vector<std::string>& allArgs);
+  int ProcessCommandLineArguments(const std::string& currentArg, size_t& idx,
+                                  const std::vector<std::string>& allArgs)
+    CM_OVERRIDE;
 
   /*
    * Get the output variable
@@ -44,7 +44,7 @@ public:
 
   cmCTestBuildAndTestHandler();
 
-  virtual void Initialize();
+  void Initialize() CM_OVERRIDE;
 
 protected:
   ///! Run CMake and build a test and then run it as a single test.
diff --git a/Source/CTest/cmCTestBuildCommand.h b/Source/CTest/cmCTestBuildCommand.h
index f420c2f..92ae216 100644
--- a/Source/CTest/cmCTestBuildCommand.h
+++ b/Source/CTest/cmCTestBuildCommand.h
@@ -26,12 +26,12 @@ class cmCTestBuildCommand : public cmCTestHandlerCommand
 {
 public:
   cmCTestBuildCommand();
-  ~cmCTestBuildCommand();
+  ~cmCTestBuildCommand() CM_OVERRIDE;
 
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmCTestBuildCommand* ni = new cmCTestBuildCommand;
     ni->CTest = this->CTest;
@@ -42,10 +42,10 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_build"; }
+  std::string GetName() const CM_OVERRIDE { return "ctest_build"; }
 
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   cmTypeMacro(cmCTestBuildCommand, cmCTestHandlerCommand);
 
@@ -65,7 +65,7 @@ protected:
     ctb_LAST
   };
 
-  cmCTestGenericHandler* InitializeHandler();
+  cmCTestGenericHandler* InitializeHandler() CM_OVERRIDE;
 };
 
 #endif
diff --git a/Source/CTest/cmCTestBuildHandler.h b/Source/CTest/cmCTestBuildHandler.h
index 48a37b7..8cc5f01 100644
--- a/Source/CTest/cmCTestBuildHandler.h
+++ b/Source/CTest/cmCTestBuildHandler.h
@@ -36,16 +36,16 @@ public:
   /*
    * The main entry point for this class
    */
-  int ProcessHandler();
+  int ProcessHandler() CM_OVERRIDE;
 
   cmCTestBuildHandler();
 
-  void PopulateCustomVectors(cmMakefile* mf);
+  void PopulateCustomVectors(cmMakefile* mf) CM_OVERRIDE;
 
   /**
    * Initialize handler
    */
-  virtual void Initialize();
+  void Initialize() CM_OVERRIDE;
 
   int GetTotalErrors() { return this->TotalErrors; }
   int GetTotalWarnings() { return this->TotalWarnings; }
diff --git a/Source/CTest/cmCTestCVS.h b/Source/CTest/cmCTestCVS.h
index 62fe01b..4d5e6a9 100644
--- a/Source/CTest/cmCTestCVS.h
+++ b/Source/CTest/cmCTestCVS.h
@@ -24,12 +24,12 @@ public:
   /** Construct with a CTest instance and update log stream.  */
   cmCTestCVS(cmCTest* ctest, std::ostream& log);
 
-  virtual ~cmCTestCVS();
+  ~cmCTestCVS() CM_OVERRIDE;
 
 private:
   // Implement cmCTestVC internal API.
-  virtual bool UpdateImpl();
-  virtual bool WriteXMLUpdates(cmXMLWriter& xml);
+  bool UpdateImpl() CM_OVERRIDE;
+  bool WriteXMLUpdates(cmXMLWriter& xml) CM_OVERRIDE;
 
   // Update status for files in each directory.
   class Directory : public std::map<std::string, PathStatus>
diff --git a/Source/CTest/cmCTestConfigureCommand.h b/Source/CTest/cmCTestConfigureCommand.h
index 9ff3d4a..a97f9f0 100644
--- a/Source/CTest/cmCTestConfigureCommand.h
+++ b/Source/CTest/cmCTestConfigureCommand.h
@@ -27,7 +27,7 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmCTestConfigureCommand* ni = new cmCTestConfigureCommand;
     ni->CTest = this->CTest;
@@ -38,12 +38,12 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_configure"; }
+  std::string GetName() const CM_OVERRIDE { return "ctest_configure"; }
 
   cmTypeMacro(cmCTestConfigureCommand, cmCTestHandlerCommand);
 
 protected:
-  cmCTestGenericHandler* InitializeHandler();
+  cmCTestGenericHandler* InitializeHandler() CM_OVERRIDE;
 
   enum
   {
diff --git a/Source/CTest/cmCTestConfigureHandler.h b/Source/CTest/cmCTestConfigureHandler.h
index 4c1a96b..a7de939 100644
--- a/Source/CTest/cmCTestConfigureHandler.h
+++ b/Source/CTest/cmCTestConfigureHandler.h
@@ -29,11 +29,11 @@ public:
   /*
    * The main entry point for this class
    */
-  int ProcessHandler();
+  int ProcessHandler() CM_OVERRIDE;
 
   cmCTestConfigureHandler();
 
-  void Initialize();
+  void Initialize() CM_OVERRIDE;
 };
 
 #endif
diff --git a/Source/CTest/cmCTestCoverageCommand.h b/Source/CTest/cmCTestCoverageCommand.h
index f60ffd5..ffd5fec 100644
--- a/Source/CTest/cmCTestCoverageCommand.h
+++ b/Source/CTest/cmCTestCoverageCommand.h
@@ -27,7 +27,7 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmCTestCoverageCommand* ni = new cmCTestCoverageCommand;
     ni->CTest = this->CTest;
@@ -38,15 +38,15 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_coverage"; }
+  std::string GetName() const CM_OVERRIDE { return "ctest_coverage"; }
 
   cmTypeMacro(cmCTestCoverageCommand, cmCTestHandlerCommand);
 
 protected:
-  cmCTestGenericHandler* InitializeHandler();
+  cmCTestGenericHandler* InitializeHandler() CM_OVERRIDE;
 
-  virtual bool CheckArgumentKeyword(std::string const& arg);
-  virtual bool CheckArgumentValue(std::string const& arg);
+  bool CheckArgumentKeyword(std::string const& arg) CM_OVERRIDE;
+  bool CheckArgumentValue(std::string const& arg) CM_OVERRIDE;
 
   enum
   {
diff --git a/Source/CTest/cmCTestCoverageHandler.h b/Source/CTest/cmCTestCoverageHandler.h
index 1773218..60fea48 100644
--- a/Source/CTest/cmCTestCoverageHandler.h
+++ b/Source/CTest/cmCTestCoverageHandler.h
@@ -45,16 +45,16 @@ public:
   /*
    * The main entry point for this class
    */
-  int ProcessHandler();
+  int ProcessHandler() CM_OVERRIDE;
 
   cmCTestCoverageHandler();
 
-  virtual void Initialize();
+  void Initialize() CM_OVERRIDE;
 
   /**
    * This method is called when reading CTest custom file
    */
-  void PopulateCustomVectors(cmMakefile* mf);
+  void PopulateCustomVectors(cmMakefile* mf) CM_OVERRIDE;
 
   /** Report coverage only for sources with these labels.  */
   void SetLabelFilter(std::set<std::string> const& labels);
diff --git a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
index e904d19..acacbcb 100644
--- a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
+++ b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
@@ -28,7 +28,7 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmCTestEmptyBinaryDirectoryCommand* ni =
       new cmCTestEmptyBinaryDirectoryCommand;
@@ -41,13 +41,13 @@ public:
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const
+  std::string GetName() const CM_OVERRIDE
   {
     return "ctest_empty_binary_directory";
   }
diff --git a/Source/CTest/cmCTestGIT.h b/Source/CTest/cmCTestGIT.h
index 685cc31..85298cb 100644
--- a/Source/CTest/cmCTestGIT.h
+++ b/Source/CTest/cmCTestGIT.h
@@ -24,15 +24,15 @@ public:
   /** Construct with a CTest instance and update log stream.  */
   cmCTestGIT(cmCTest* ctest, std::ostream& log);
 
-  virtual ~cmCTestGIT();
+  ~cmCTestGIT() CM_OVERRIDE;
 
 private:
   unsigned int CurrentGitVersion;
   unsigned int GetGitVersion();
   std::string GetWorkingRevision();
-  virtual void NoteOldRevision();
-  virtual void NoteNewRevision();
-  virtual bool UpdateImpl();
+  void NoteOldRevision() CM_OVERRIDE;
+  void NoteNewRevision() CM_OVERRIDE;
+  bool UpdateImpl() CM_OVERRIDE;
 
   std::string FindGitDir();
   std::string FindTopDir();
@@ -41,8 +41,8 @@ private:
   bool UpdateByCustom(std::string const& custom);
   bool UpdateInternal();
 
-  void LoadRevisions();
-  void LoadModifications();
+  void LoadRevisions() CM_OVERRIDE;
+  void LoadModifications() CM_OVERRIDE;
 
   // "public" needed by older Sun compilers
 public:
diff --git a/Source/CTest/cmCTestGenericHandler.h b/Source/CTest/cmCTestGenericHandler.h
index ad349ac..9949c3a 100644
--- a/Source/CTest/cmCTestGenericHandler.h
+++ b/Source/CTest/cmCTestGenericHandler.h
@@ -74,7 +74,7 @@ public:
    * Construct handler
    */
   cmCTestGenericHandler();
-  virtual ~cmCTestGenericHandler();
+  ~cmCTestGenericHandler() CM_OVERRIDE;
 
   typedef std::map<std::string, std::string> t_StringToString;
 
diff --git a/Source/CTest/cmCTestGlobalVC.h b/Source/CTest/cmCTestGlobalVC.h
index 9a5357f..7ea3440 100644
--- a/Source/CTest/cmCTestGlobalVC.h
+++ b/Source/CTest/cmCTestGlobalVC.h
@@ -26,11 +26,11 @@ public:
   /** Construct with a CTest instance and update log stream.  */
   cmCTestGlobalVC(cmCTest* ctest, std::ostream& log);
 
-  virtual ~cmCTestGlobalVC();
+  ~cmCTestGlobalVC() CM_OVERRIDE;
 
 protected:
   // Implement cmCTestVC internal API.
-  virtual bool WriteXMLUpdates(cmXMLWriter& xml);
+  bool WriteXMLUpdates(cmXMLWriter& xml) CM_OVERRIDE;
 
   /** Represent a vcs-reported action for one path in a revision.  */
   struct Change
diff --git a/Source/CTest/cmCTestHG.cxx b/Source/CTest/cmCTestHG.cxx
index 9589e05..298804b 100644
--- a/Source/CTest/cmCTestHG.cxx
+++ b/Source/CTest/cmCTestHG.cxx
@@ -171,7 +171,7 @@ public:
   {
     this->InitializeParser();
   }
-  ~LogParser() { this->CleanupParser(); }
+  ~LogParser() CM_OVERRIDE { this->CleanupParser(); }
 private:
   cmCTestHG* HG;
 
diff --git a/Source/CTest/cmCTestHG.h b/Source/CTest/cmCTestHG.h
index 8cc8c7a..c4ce08c 100644
--- a/Source/CTest/cmCTestHG.h
+++ b/Source/CTest/cmCTestHG.h
@@ -24,16 +24,16 @@ public:
   /** Construct with a CTest instance and update log stream.  */
   cmCTestHG(cmCTest* ctest, std::ostream& log);
 
-  virtual ~cmCTestHG();
+  ~cmCTestHG() CM_OVERRIDE;
 
 private:
   std::string GetWorkingRevision();
-  virtual void NoteOldRevision();
-  virtual void NoteNewRevision();
-  virtual bool UpdateImpl();
+  void NoteOldRevision() CM_OVERRIDE;
+  void NoteNewRevision() CM_OVERRIDE;
+  bool UpdateImpl() CM_OVERRIDE;
 
-  void LoadRevisions();
-  void LoadModifications();
+  void LoadRevisions() CM_OVERRIDE;
+  void LoadModifications() CM_OVERRIDE;
 
   // Parsing helper classes.
   class IdentifyParser;
diff --git a/Source/CTest/cmCTestHandlerCommand.h b/Source/CTest/cmCTestHandlerCommand.h
index 7248832..0468bbc 100644
--- a/Source/CTest/cmCTestHandlerCommand.h
+++ b/Source/CTest/cmCTestHandlerCommand.h
@@ -30,8 +30,8 @@ public:
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   cmTypeMacro(cmCTestHandlerCommand, cmCTestCommand);
 
diff --git a/Source/CTest/cmCTestMemCheckCommand.h b/Source/CTest/cmCTestMemCheckCommand.h
index 245892c..2ba33ae 100644
--- a/Source/CTest/cmCTestMemCheckCommand.h
+++ b/Source/CTest/cmCTestMemCheckCommand.h
@@ -29,7 +29,7 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmCTestMemCheckCommand* ni = new cmCTestMemCheckCommand;
     ni->CTest = this->CTest;
@@ -40,12 +40,12 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_memcheck"; }
+  std::string GetName() const CM_OVERRIDE { return "ctest_memcheck"; }
 
   cmTypeMacro(cmCTestMemCheckCommand, cmCTestTestCommand);
 
 protected:
-  cmCTestGenericHandler* InitializeActualHandler();
+  cmCTestGenericHandler* InitializeActualHandler() CM_OVERRIDE;
 };
 
 #endif
diff --git a/Source/CTest/cmCTestMemCheckHandler.h b/Source/CTest/cmCTestMemCheckHandler.h
index 8f0cc47..a005d54 100644
--- a/Source/CTest/cmCTestMemCheckHandler.h
+++ b/Source/CTest/cmCTestMemCheckHandler.h
@@ -33,16 +33,17 @@ class cmCTestMemCheckHandler : public cmCTestTestHandler
 public:
   cmTypeMacro(cmCTestMemCheckHandler, cmCTestTestHandler);
 
-  void PopulateCustomVectors(cmMakefile* mf);
+  void PopulateCustomVectors(cmMakefile* mf) CM_OVERRIDE;
 
   cmCTestMemCheckHandler();
 
-  void Initialize();
+  void Initialize() CM_OVERRIDE;
 
 protected:
-  virtual int PreProcessHandler();
-  virtual int PostProcessHandler();
-  virtual void GenerateTestCommand(std::vector<std::string>& args, int test);
+  int PreProcessHandler() CM_OVERRIDE;
+  int PostProcessHandler() CM_OVERRIDE;
+  void GenerateTestCommand(std::vector<std::string>& args,
+                           int test) CM_OVERRIDE;
 
 private:
   enum
@@ -125,7 +126,7 @@ private:
   /**
    * Generate the Dart compatible output
    */
-  void GenerateDartOutput(cmXMLWriter& xml);
+  void GenerateDartOutput(cmXMLWriter& xml) CM_OVERRIDE;
 
   std::vector<std::string> CustomPreMemCheck;
   std::vector<std::string> CustomPostMemCheck;
diff --git a/Source/CTest/cmCTestP4.h b/Source/CTest/cmCTestP4.h
index 917751e..84e4f96 100644
--- a/Source/CTest/cmCTestP4.h
+++ b/Source/CTest/cmCTestP4.h
@@ -27,7 +27,7 @@ public:
   /** Construct with a CTest instance and update log stream.  */
   cmCTestP4(cmCTest* ctest, std::ostream& log);
 
-  virtual ~cmCTestP4();
+  ~cmCTestP4() CM_OVERRIDE;
 
 private:
   std::vector<std::string> ChangeLists;
@@ -54,13 +54,13 @@ private:
   void SetP4Options(std::vector<char const*>& options);
 
   std::string GetWorkingRevision();
-  virtual void NoteOldRevision();
-  virtual void NoteNewRevision();
-  virtual bool UpdateImpl();
+  void NoteOldRevision() CM_OVERRIDE;
+  void NoteNewRevision() CM_OVERRIDE;
+  bool UpdateImpl() CM_OVERRIDE;
   bool UpdateCustom(const std::string& custom);
 
-  void LoadRevisions();
-  void LoadModifications();
+  void LoadRevisions() CM_OVERRIDE;
+  void LoadModifications() CM_OVERRIDE;
 
   // Parsing helper classes.
   class IdentifyParser;
diff --git a/Source/CTest/cmCTestReadCustomFilesCommand.h b/Source/CTest/cmCTestReadCustomFilesCommand.h
index 713fc66..6cce7c8 100644
--- a/Source/CTest/cmCTestReadCustomFilesCommand.h
+++ b/Source/CTest/cmCTestReadCustomFilesCommand.h
@@ -28,7 +28,7 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmCTestReadCustomFilesCommand* ni = new cmCTestReadCustomFilesCommand;
     ni->CTest = this->CTest;
@@ -39,13 +39,13 @@ public:
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_read_custom_files"; }
+  std::string GetName() const CM_OVERRIDE { return "ctest_read_custom_files"; }
 
   cmTypeMacro(cmCTestReadCustomFilesCommand, cmCTestCommand);
 };
diff --git a/Source/CTest/cmCTestRunScriptCommand.h b/Source/CTest/cmCTestRunScriptCommand.h
index c503516..9ea0999 100644
--- a/Source/CTest/cmCTestRunScriptCommand.h
+++ b/Source/CTest/cmCTestRunScriptCommand.h
@@ -28,7 +28,7 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmCTestRunScriptCommand* ni = new cmCTestRunScriptCommand;
     ni->CTest = this->CTest;
@@ -40,13 +40,13 @@ public:
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_run_script"; }
+  std::string GetName() const CM_OVERRIDE { return "ctest_run_script"; }
 
   cmTypeMacro(cmCTestRunScriptCommand, cmCTestCommand);
 };
diff --git a/Source/CTest/cmCTestSVN.cxx b/Source/CTest/cmCTestSVN.cxx
index 074bd3d..e4b6e25 100644
--- a/Source/CTest/cmCTestSVN.cxx
+++ b/Source/CTest/cmCTestSVN.cxx
@@ -311,7 +311,7 @@ public:
   {
     this->InitializeParser();
   }
-  ~LogParser() { this->CleanupParser(); }
+  ~LogParser() CM_OVERRIDE { this->CleanupParser(); }
 private:
   cmCTestSVN* SVN;
   cmCTestSVN::SVNInfo& SVNRepo;
diff --git a/Source/CTest/cmCTestSVN.h b/Source/CTest/cmCTestSVN.h
index e596bdc..4f3eb88 100644
--- a/Source/CTest/cmCTestSVN.h
+++ b/Source/CTest/cmCTestSVN.h
@@ -26,14 +26,14 @@ public:
   /** Construct with a CTest instance and update log stream.  */
   cmCTestSVN(cmCTest* ctest, std::ostream& log);
 
-  virtual ~cmCTestSVN();
+  ~cmCTestSVN() CM_OVERRIDE;
 
 private:
   // Implement cmCTestVC internal API.
-  virtual void CleanupImpl();
-  virtual void NoteOldRevision();
-  virtual void NoteNewRevision();
-  virtual bool UpdateImpl();
+  void CleanupImpl() CM_OVERRIDE;
+  void NoteOldRevision() CM_OVERRIDE;
+  void NoteNewRevision() CM_OVERRIDE;
+  bool UpdateImpl() CM_OVERRIDE;
 
   bool RunSVNCommand(std::vector<char const*> const& parameters,
                      OutputParser* out, OutputParser* err);
@@ -78,8 +78,8 @@ private:
 
   std::string LoadInfo(SVNInfo& svninfo);
   void LoadExternals();
-  void LoadModifications();
-  void LoadRevisions();
+  void LoadModifications() CM_OVERRIDE;
+  void LoadRevisions() CM_OVERRIDE;
   void LoadRevisions(SVNInfo& svninfo);
 
   void GuessBase(SVNInfo& svninfo, std::vector<Change> const& changes);
@@ -87,7 +87,7 @@ private:
   void DoRevisionSVN(Revision const& revision,
                      std::vector<Change> const& changes);
 
-  void WriteXMLGlobal(cmXMLWriter& xml);
+  void WriteXMLGlobal(cmXMLWriter& xml) CM_OVERRIDE;
 
   // Parsing helper classes.
   class InfoParser;
diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx
index 028cfdd..44b6b93 100644
--- a/Source/CTest/cmCTestScriptHandler.cxx
+++ b/Source/CTest/cmCTestScriptHandler.cxx
@@ -59,7 +59,7 @@ class cmCTestScriptFunctionBlocker : public cmFunctionBlocker
 {
 public:
   cmCTestScriptFunctionBlocker() {}
-  virtual ~cmCTestScriptFunctionBlocker() {}
+  ~cmCTestScriptFunctionBlocker() CM_OVERRIDE {}
   bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf,
                          cmExecutionStatus&) CM_OVERRIDE;
   // virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf);
diff --git a/Source/CTest/cmCTestScriptHandler.h b/Source/CTest/cmCTestScriptHandler.h
index e09e040..4403030 100644
--- a/Source/CTest/cmCTestScriptHandler.h
+++ b/Source/CTest/cmCTestScriptHandler.h
@@ -71,7 +71,7 @@ public:
   /**
    * Run a dashboard using a specified confiuration script
    */
-  int ProcessHandler();
+  int ProcessHandler() CM_OVERRIDE;
 
   /*
    * Run a script
@@ -104,9 +104,9 @@ public:
   double GetRemainingTimeAllowed();
 
   cmCTestScriptHandler();
-  ~cmCTestScriptHandler();
+  ~cmCTestScriptHandler() CM_OVERRIDE;
 
-  void Initialize();
+  void Initialize() CM_OVERRIDE;
 
   void CreateCMake();
   cmake* GetCMake() { return this->CMake; }
diff --git a/Source/CTest/cmCTestSleepCommand.h b/Source/CTest/cmCTestSleepCommand.h
index ff7f146..7981fa2 100644
--- a/Source/CTest/cmCTestSleepCommand.h
+++ b/Source/CTest/cmCTestSleepCommand.h
@@ -28,7 +28,7 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmCTestSleepCommand* ni = new cmCTestSleepCommand;
     ni->CTest = this->CTest;
@@ -40,13 +40,13 @@ public:
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_sleep"; }
+  std::string GetName() const CM_OVERRIDE { return "ctest_sleep"; }
 
   cmTypeMacro(cmCTestSleepCommand, cmCTestCommand);
 };
diff --git a/Source/CTest/cmCTestStartCommand.h b/Source/CTest/cmCTestStartCommand.h
index 2aa6281..e3f8f8b 100644
--- a/Source/CTest/cmCTestStartCommand.h
+++ b/Source/CTest/cmCTestStartCommand.h
@@ -27,7 +27,7 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmCTestStartCommand* ni = new cmCTestStartCommand;
     ni->CTest = this->CTest;
@@ -41,8 +41,8 @@ public:
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * Will this invocation of ctest_start create a new TAG file?
@@ -57,7 +57,7 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_start"; }
+  std::string GetName() const CM_OVERRIDE { return "ctest_start"; }
 
   cmTypeMacro(cmCTestStartCommand, cmCTestCommand);
 
diff --git a/Source/CTest/cmCTestSubmitCommand.h b/Source/CTest/cmCTestSubmitCommand.h
index 6323d8c..7c3d6cd 100644
--- a/Source/CTest/cmCTestSubmitCommand.h
+++ b/Source/CTest/cmCTestSubmitCommand.h
@@ -38,7 +38,7 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmCTestSubmitCommand* ni = new cmCTestSubmitCommand;
     ni->CTest = this->CTest;
@@ -46,21 +46,21 @@ public:
     return ni;
   }
 
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_submit"; }
+  std::string GetName() const CM_OVERRIDE { return "ctest_submit"; }
 
   cmTypeMacro(cmCTestSubmitCommand, cmCTestHandlerCommand);
 
 protected:
-  cmCTestGenericHandler* InitializeHandler();
+  cmCTestGenericHandler* InitializeHandler() CM_OVERRIDE;
 
-  virtual bool CheckArgumentKeyword(std::string const& arg);
-  virtual bool CheckArgumentValue(std::string const& arg);
+  bool CheckArgumentKeyword(std::string const& arg) CM_OVERRIDE;
+  bool CheckArgumentValue(std::string const& arg) CM_OVERRIDE;
 
   enum
   {
diff --git a/Source/CTest/cmCTestSubmitHandler.cxx b/Source/CTest/cmCTestSubmitHandler.cxx
index 85e243f..3aacde0 100644
--- a/Source/CTest/cmCTestSubmitHandler.cxx
+++ b/Source/CTest/cmCTestSubmitHandler.cxx
@@ -41,7 +41,7 @@ class cmCTestSubmitHandler::ResponseParser : public cmXMLParser
 {
 public:
   ResponseParser() { this->Status = STATUS_OK; }
-  ~ResponseParser() {}
+  ~ResponseParser() CM_OVERRIDE {}
 
 public:
   enum StatusType
diff --git a/Source/CTest/cmCTestSubmitHandler.h b/Source/CTest/cmCTestSubmitHandler.h
index 87fa142..c2c9a85 100644
--- a/Source/CTest/cmCTestSubmitHandler.h
+++ b/Source/CTest/cmCTestSubmitHandler.h
@@ -26,14 +26,14 @@ public:
   cmTypeMacro(cmCTestSubmitHandler, cmCTestGenericHandler);
 
   cmCTestSubmitHandler();
-  ~cmCTestSubmitHandler() { this->LogFile = 0; }
+  ~cmCTestSubmitHandler() CM_OVERRIDE { this->LogFile = 0; }
 
   /*
    * The main entry point for this class
    */
-  int ProcessHandler();
+  int ProcessHandler() CM_OVERRIDE;
 
-  void Initialize();
+  void Initialize() CM_OVERRIDE;
 
   /** Specify a set of parts (by name) to submit.  */
   void SelectParts(std::set<cmCTest::Part> const& parts);
diff --git a/Source/CTest/cmCTestTestCommand.h b/Source/CTest/cmCTestTestCommand.h
index 212213e..f652971 100644
--- a/Source/CTest/cmCTestTestCommand.h
+++ b/Source/CTest/cmCTestTestCommand.h
@@ -27,7 +27,7 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmCTestTestCommand* ni = new cmCTestTestCommand;
     ni->CTest = this->CTest;
@@ -38,13 +38,13 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_test"; }
+  std::string GetName() const CM_OVERRIDE { return "ctest_test"; }
 
   cmTypeMacro(cmCTestTestCommand, cmCTestHandlerCommand);
 
 protected:
   virtual cmCTestGenericHandler* InitializeActualHandler();
-  cmCTestGenericHandler* InitializeHandler();
+  cmCTestGenericHandler* InitializeHandler() CM_OVERRIDE;
 
   enum
   {
diff --git a/Source/CTest/cmCTestTestHandler.h b/Source/CTest/cmCTestTestHandler.h
index 4b74ce0..a085a82 100644
--- a/Source/CTest/cmCTestTestHandler.h
+++ b/Source/CTest/cmCTestTestHandler.h
@@ -36,7 +36,7 @@ public:
   /**
    * The main entry point for this class
    */
-  int ProcessHandler();
+  int ProcessHandler() CM_OVERRIDE;
 
   /**
    * When both -R and -I are used should te resulting test list be the
@@ -54,7 +54,7 @@ public:
   /**
    * This method is called when reading CTest custom file
    */
-  void PopulateCustomVectors(cmMakefile* mf);
+  void PopulateCustomVectors(cmMakefile* mf) CM_OVERRIDE;
 
   ///! Control the use of the regular expresisons, call these methods to turn
   /// them on
@@ -90,7 +90,7 @@ public:
    */
   bool SetTestsProperties(const std::vector<std::string>& args);
 
-  void Initialize();
+  void Initialize() CM_OVERRIDE;
 
   // NOTE: This struct is Saved/Restored
   // in cmCTestTestHandler, if you add to this class
diff --git a/Source/CTest/cmCTestUpdateCommand.h b/Source/CTest/cmCTestUpdateCommand.h
index e807193..6b5bbab 100644
--- a/Source/CTest/cmCTestUpdateCommand.h
+++ b/Source/CTest/cmCTestUpdateCommand.h
@@ -27,7 +27,7 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmCTestUpdateCommand* ni = new cmCTestUpdateCommand;
     ni->CTest = this->CTest;
@@ -38,12 +38,12 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_update"; }
+  std::string GetName() const CM_OVERRIDE { return "ctest_update"; }
 
   cmTypeMacro(cmCTestUpdateCommand, cmCTestHandlerCommand);
 
 protected:
-  cmCTestGenericHandler* InitializeHandler();
+  cmCTestGenericHandler* InitializeHandler() CM_OVERRIDE;
 };
 
 #endif
diff --git a/Source/CTest/cmCTestUpdateHandler.h b/Source/CTest/cmCTestUpdateHandler.h
index d44e619..6733c8c 100644
--- a/Source/CTest/cmCTestUpdateHandler.h
+++ b/Source/CTest/cmCTestUpdateHandler.h
@@ -29,7 +29,7 @@ public:
   /*
    * The main entry point for this class
    */
-  int ProcessHandler();
+  int ProcessHandler() CM_OVERRIDE;
 
   cmCTestUpdateHandler();
 
@@ -48,7 +48,7 @@ public:
   /**
    * Initialize handler
    */
-  virtual void Initialize();
+  void Initialize() CM_OVERRIDE;
 
 private:
   // Some structures needed for update
diff --git a/Source/CTest/cmCTestUploadCommand.h b/Source/CTest/cmCTestUploadCommand.h
index 551be2b..923995d 100644
--- a/Source/CTest/cmCTestUploadCommand.h
+++ b/Source/CTest/cmCTestUploadCommand.h
@@ -30,7 +30,7 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmCTestUploadCommand* ni = new cmCTestUploadCommand;
     ni->CTest = this->CTest;
@@ -41,15 +41,15 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_upload"; }
+  std::string GetName() const CM_OVERRIDE { return "ctest_upload"; }
 
   cmTypeMacro(cmCTestUploadCommand, cmCTestHandlerCommand);
 
 protected:
-  cmCTestGenericHandler* InitializeHandler();
+  cmCTestGenericHandler* InitializeHandler() CM_OVERRIDE;
 
-  virtual bool CheckArgumentKeyword(std::string const& arg);
-  virtual bool CheckArgumentValue(std::string const& arg);
+  bool CheckArgumentKeyword(std::string const& arg) CM_OVERRIDE;
+  bool CheckArgumentValue(std::string const& arg) CM_OVERRIDE;
 
   enum
   {
diff --git a/Source/CTest/cmCTestUploadHandler.h b/Source/CTest/cmCTestUploadHandler.h
index 23ed35a..8b824d6 100644
--- a/Source/CTest/cmCTestUploadHandler.h
+++ b/Source/CTest/cmCTestUploadHandler.h
@@ -26,14 +26,14 @@ public:
   cmTypeMacro(cmCTestUploadHandler, cmCTestGenericHandler);
 
   cmCTestUploadHandler();
-  ~cmCTestUploadHandler() {}
+  ~cmCTestUploadHandler() CM_OVERRIDE {}
 
   /*
    * The main entry point for this class
    */
-  int ProcessHandler();
+  int ProcessHandler() CM_OVERRIDE;
 
-  void Initialize();
+  void Initialize() CM_OVERRIDE;
 
   /** Specify a set of files to submit.  */
   void SetFiles(cmCTest::SetOfStrings const& files);
diff --git a/Source/CTest/cmParseCacheCoverage.h b/Source/CTest/cmParseCacheCoverage.h
index bd331d0..65b1d10 100644
--- a/Source/CTest/cmParseCacheCoverage.h
+++ b/Source/CTest/cmParseCacheCoverage.h
@@ -28,7 +28,7 @@ public:
 
 protected:
   // implement virtual from parent
-  bool LoadCoverageData(const char* dir);
+  bool LoadCoverageData(const char* dir) CM_OVERRIDE;
   // remove files with no coverage
   void RemoveUnCoveredFiles();
   // Read a single mcov file
diff --git a/Source/CTest/cmParseCoberturaCoverage.cxx b/Source/CTest/cmParseCoberturaCoverage.cxx
index f1c37ed..1a3fe3c 100644
--- a/Source/CTest/cmParseCoberturaCoverage.cxx
+++ b/Source/CTest/cmParseCoberturaCoverage.cxx
@@ -20,7 +20,7 @@ public:
     this->CurFileName = "";
   }
 
-  virtual ~XMLParser() {}
+  ~XMLParser() CM_OVERRIDE {}
 
 protected:
   void EndElement(const std::string& name) CM_OVERRIDE
diff --git a/Source/CTest/cmParseGTMCoverage.h b/Source/CTest/cmParseGTMCoverage.h
index bc2f2ec..4188689 100644
--- a/Source/CTest/cmParseGTMCoverage.h
+++ b/Source/CTest/cmParseGTMCoverage.h
@@ -28,7 +28,7 @@ public:
 
 protected:
   // implement virtual from parent
-  bool LoadCoverageData(const char* dir);
+  bool LoadCoverageData(const char* dir) CM_OVERRIDE;
   // Read a single mcov file
   bool ReadMCovFile(const char* f);
   // find out what line in a mumps file (filepath) the given entry point
diff --git a/Source/CTest/cmParseJacocoCoverage.cxx b/Source/CTest/cmParseJacocoCoverage.cxx
index 27ccf58..9325812 100644
--- a/Source/CTest/cmParseJacocoCoverage.cxx
+++ b/Source/CTest/cmParseJacocoCoverage.cxx
@@ -20,7 +20,7 @@ public:
     this->PackageName = "";
   }
 
-  virtual ~XMLParser() {}
+  ~XMLParser() CM_OVERRIDE {}
 
 protected:
   void EndElement(const std::string&) CM_OVERRIDE {}
diff --git a/Source/CursesDialog/cmCursesBoolWidget.h b/Source/CursesDialog/cmCursesBoolWidget.h
index 49be45a..d2899ee 100644
--- a/Source/CursesDialog/cmCursesBoolWidget.h
+++ b/Source/CursesDialog/cmCursesBoolWidget.h
@@ -25,7 +25,7 @@ public:
   // Handle user input. Called by the container of this widget
   // when this widget has focus. Returns true if the input was
   // handled.
-  virtual bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w);
+  bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE;
 
   // Description:
   // Set/Get the value (on/off).
diff --git a/Source/CursesDialog/cmCursesDummyWidget.h b/Source/CursesDialog/cmCursesDummyWidget.h
index 9a3df29..e6ca91e 100644
--- a/Source/CursesDialog/cmCursesDummyWidget.h
+++ b/Source/CursesDialog/cmCursesDummyWidget.h
@@ -25,7 +25,7 @@ public:
   // Handle user input. Called by the container of this widget
   // when this widget has focus. Returns true if the input was
   // handled.
-  virtual bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w);
+  bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE;
 
 protected:
   cmCursesDummyWidget(const cmCursesDummyWidget& from);
diff --git a/Source/CursesDialog/cmCursesLabelWidget.h b/Source/CursesDialog/cmCursesLabelWidget.h
index c31a58c..ff645af 100644
--- a/Source/CursesDialog/cmCursesLabelWidget.h
+++ b/Source/CursesDialog/cmCursesLabelWidget.h
@@ -21,13 +21,13 @@ class cmCursesLabelWidget : public cmCursesWidget
 public:
   cmCursesLabelWidget(int width, int height, int left, int top,
                       const std::string& name);
-  virtual ~cmCursesLabelWidget();
+  ~cmCursesLabelWidget() CM_OVERRIDE;
 
   // Description:
   // Handle user input. Called by the container of this widget
   // when this widget has focus. Returns true if the input was
   // handled
-  virtual bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w);
+  bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE;
 
 protected:
   cmCursesLabelWidget(const cmCursesLabelWidget& from);
diff --git a/Source/CursesDialog/cmCursesLongMessageForm.h b/Source/CursesDialog/cmCursesLongMessageForm.h
index 73ccfc4..a12ed2f 100644
--- a/Source/CursesDialog/cmCursesLongMessageForm.h
+++ b/Source/CursesDialog/cmCursesLongMessageForm.h
@@ -23,16 +23,16 @@ class cmCursesLongMessageForm : public cmCursesForm
 public:
   cmCursesLongMessageForm(std::vector<std::string> const& messages,
                           const char* title);
-  virtual ~cmCursesLongMessageForm();
+  ~cmCursesLongMessageForm() CM_OVERRIDE;
 
   // Description:
   // Handle user input.
-  virtual void HandleInput();
+  void HandleInput() CM_OVERRIDE;
 
   // Description:
   // Display form. Use a window of size width x height, starting
   // at top, left.
-  virtual void Render(int left, int top, int width, int height);
+  void Render(int left, int top, int width, int height) CM_OVERRIDE;
 
   // Description:
   // This method should normally  called only by the form.
@@ -42,7 +42,7 @@ public:
   // Description:
   // This method should normally  called only by the form.
   // The only exception is during a resize.
-  virtual void UpdateStatusBar();
+  void UpdateStatusBar() CM_OVERRIDE;
 
 protected:
   cmCursesLongMessageForm(const cmCursesLongMessageForm& from);
diff --git a/Source/CursesDialog/cmCursesMainForm.h b/Source/CursesDialog/cmCursesMainForm.h
index 9aa0f67..a8e99b6 100644
--- a/Source/CursesDialog/cmCursesMainForm.h
+++ b/Source/CursesDialog/cmCursesMainForm.h
@@ -30,7 +30,7 @@ class cmCursesMainForm : public cmCursesForm
 {
 public:
   cmCursesMainForm(std::vector<std::string> const& args, int initwidth);
-  virtual ~cmCursesMainForm();
+  ~cmCursesMainForm() CM_OVERRIDE;
 
   /**
    * Set the widgets which represent the cache entries.
@@ -40,13 +40,13 @@ public:
   /**
    * Handle user input.
    */
-  virtual void HandleInput();
+  void HandleInput() CM_OVERRIDE;
 
   /**
    * Display form. Use a window of size width x height, starting
    * at top, left.
    */
-  virtual void Render(int left, int top, int width, int height);
+  void Render(int left, int top, int width, int height) CM_OVERRIDE;
 
   /**
    * Returns true if an entry with the given key is in the
@@ -67,7 +67,7 @@ public:
    * exception is during a resize. The optional argument specifies the
    * string to be displayed in the status bar.
    */
-  virtual void UpdateStatusBar() { this->UpdateStatusBar(0); }
+  void UpdateStatusBar() CM_OVERRIDE { this->UpdateStatusBar(0); }
   virtual void UpdateStatusBar(const char* message);
 
   /**
@@ -83,7 +83,7 @@ public:
    * During a CMake run, an error handle should add errors
    * to be displayed afterwards.
    */
-  virtual void AddError(const char* message, const char* title);
+  void AddError(const char* message, const char* title) CM_OVERRIDE;
 
   /**
    * Used to do a configure. If argument is specified, it does only the check
diff --git a/Source/CursesDialog/cmCursesOptionsWidget.h b/Source/CursesDialog/cmCursesOptionsWidget.h
index a17f2d5..f88b6bc 100644
--- a/Source/CursesDialog/cmCursesOptionsWidget.h
+++ b/Source/CursesDialog/cmCursesOptionsWidget.h
@@ -25,7 +25,7 @@ public:
   // Handle user input. Called by the container of this widget
   // when this widget has focus. Returns true if the input was
   // handled.
-  virtual bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w);
+  bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE;
   void SetOption(const std::string&);
   void AddOption(std::string const&);
   void NextOption();
diff --git a/Source/CursesDialog/cmCursesPathWidget.h b/Source/CursesDialog/cmCursesPathWidget.h
index 18d298a..cd26df6 100644
--- a/Source/CursesDialog/cmCursesPathWidget.h
+++ b/Source/CursesDialog/cmCursesPathWidget.h
@@ -23,9 +23,9 @@ public:
    * This method is called when different keys are pressed. The
    * subclass can have a special implementation handler for this.
    */
-  virtual void OnTab(cmCursesMainForm* fm, WINDOW* w);
-  virtual void OnReturn(cmCursesMainForm* fm, WINDOW* w);
-  virtual void OnType(int& key, cmCursesMainForm* fm, WINDOW* w);
+  void OnTab(cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE;
+  void OnReturn(cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE;
+  void OnType(int& key, cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE;
 
 protected:
   cmCursesPathWidget(const cmCursesPathWidget& from);
diff --git a/Source/CursesDialog/cmCursesStringWidget.h b/Source/CursesDialog/cmCursesStringWidget.h
index fc1b2ba..c8ca482 100644
--- a/Source/CursesDialog/cmCursesStringWidget.h
+++ b/Source/CursesDialog/cmCursesStringWidget.h
@@ -32,14 +32,14 @@ public:
    * when this widget has focus. Returns true if the input was
    * handled.
    */
-  virtual bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w);
+  bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE;
 
   /**
    * Set/Get the string.
    */
   void SetString(const std::string& value);
   const char* GetString();
-  virtual const char* GetValue();
+  const char* GetValue() CM_OVERRIDE;
 
   /**
    * Set/Get InEdit flag. Can be used to tell the widget to leave
@@ -61,7 +61,7 @@ public:
    * in the toolbar and return true. Otherwise, return false
    * and the parent widget will print.
    */
-  virtual bool PrintKeys();
+  bool PrintKeys() CM_OVERRIDE;
 
 protected:
   cmCursesStringWidget(const cmCursesStringWidget& from);
diff --git a/Source/cmAddCompileOptionsCommand.h b/Source/cmAddCompileOptionsCommand.h
index 5c073c8..dba1acd 100644
--- a/Source/cmAddCompileOptionsCommand.h
+++ b/Source/cmAddCompileOptionsCommand.h
@@ -20,19 +20,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmAddCompileOptionsCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmAddCompileOptionsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_compile_options"; }
+  std::string GetName() const CM_OVERRIDE { return "add_compile_options"; }
 
   cmTypeMacro(cmAddCompileOptionsCommand, cmCommand);
 };
diff --git a/Source/cmAddCustomCommandCommand.h b/Source/cmAddCustomCommandCommand.h
index ccbd50c..1164d46 100644
--- a/Source/cmAddCustomCommandCommand.h
+++ b/Source/cmAddCustomCommandCommand.h
@@ -26,19 +26,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmAddCustomCommandCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmAddCustomCommandCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_custom_command"; }
+  std::string GetName() const CM_OVERRIDE { return "add_custom_command"; }
 
   cmTypeMacro(cmAddCustomCommandCommand, cmCommand);
 
diff --git a/Source/cmAddCustomTargetCommand.h b/Source/cmAddCustomTargetCommand.h
index 9c376c0..120d4d4 100644
--- a/Source/cmAddCustomTargetCommand.h
+++ b/Source/cmAddCustomTargetCommand.h
@@ -27,19 +27,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmAddCustomTargetCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmAddCustomTargetCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_custom_target"; }
+  std::string GetName() const CM_OVERRIDE { return "add_custom_target"; }
 
   cmTypeMacro(cmAddCustomTargetCommand, cmCommand);
 };
diff --git a/Source/cmAddDefinitionsCommand.h b/Source/cmAddDefinitionsCommand.h
index 959ed64..b30001c 100644
--- a/Source/cmAddDefinitionsCommand.h
+++ b/Source/cmAddDefinitionsCommand.h
@@ -26,19 +26,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmAddDefinitionsCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmAddDefinitionsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_definitions"; }
+  std::string GetName() const CM_OVERRIDE { return "add_definitions"; }
 
   cmTypeMacro(cmAddDefinitionsCommand, cmCommand);
 };
diff --git a/Source/cmAddDependenciesCommand.h b/Source/cmAddDependenciesCommand.h
index 202d072..c059ff2 100644
--- a/Source/cmAddDependenciesCommand.h
+++ b/Source/cmAddDependenciesCommand.h
@@ -25,19 +25,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmAddDependenciesCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmAddDependenciesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_dependencies"; }
+  std::string GetName() const CM_OVERRIDE { return "add_dependencies"; }
 
   cmTypeMacro(cmAddDependenciesCommand, cmCommand);
 };
diff --git a/Source/cmAddExecutableCommand.h b/Source/cmAddExecutableCommand.h
index 1e3181f..133f5bf 100644
--- a/Source/cmAddExecutableCommand.h
+++ b/Source/cmAddExecutableCommand.h
@@ -26,19 +26,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmAddExecutableCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmAddExecutableCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_executable"; }
+  std::string GetName() const CM_OVERRIDE { return "add_executable"; }
 
   cmTypeMacro(cmAddExecutableCommand, cmCommand);
 };
diff --git a/Source/cmAddLibraryCommand.h b/Source/cmAddLibraryCommand.h
index 0f0f768..20f1bc9 100644
--- a/Source/cmAddLibraryCommand.h
+++ b/Source/cmAddLibraryCommand.h
@@ -26,19 +26,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmAddLibraryCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmAddLibraryCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_library"; }
+  std::string GetName() const CM_OVERRIDE { return "add_library"; }
 
   cmTypeMacro(cmAddLibraryCommand, cmCommand);
 };
diff --git a/Source/cmAddSubDirectoryCommand.h b/Source/cmAddSubDirectoryCommand.h
index 786c8b0..ec1d2c8 100644
--- a/Source/cmAddSubDirectoryCommand.h
+++ b/Source/cmAddSubDirectoryCommand.h
@@ -27,19 +27,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmAddSubDirectoryCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmAddSubDirectoryCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_subdirectory"; }
+  std::string GetName() const CM_OVERRIDE { return "add_subdirectory"; }
 
   cmTypeMacro(cmAddSubDirectoryCommand, cmCommand);
 };
diff --git a/Source/cmAddTestCommand.h b/Source/cmAddTestCommand.h
index 295fb78..abff0c2 100644
--- a/Source/cmAddTestCommand.h
+++ b/Source/cmAddTestCommand.h
@@ -25,19 +25,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmAddTestCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmAddTestCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_test"; }
+  std::string GetName() const CM_OVERRIDE { return "add_test"; }
 
   cmTypeMacro(cmAddTestCommand, cmCommand);
 
diff --git a/Source/cmAuxSourceDirectoryCommand.h b/Source/cmAuxSourceDirectoryCommand.h
index b5943f5..6301cb2 100644
--- a/Source/cmAuxSourceDirectoryCommand.h
+++ b/Source/cmAuxSourceDirectoryCommand.h
@@ -29,19 +29,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmAuxSourceDirectoryCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmAuxSourceDirectoryCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "aux_source_directory"; }
+  std::string GetName() const CM_OVERRIDE { return "aux_source_directory"; }
 
   cmTypeMacro(cmAuxSourceDirectoryCommand, cmCommand);
 };
diff --git a/Source/cmBreakCommand.h b/Source/cmBreakCommand.h
index 270d3e6..3b585e2 100644
--- a/Source/cmBreakCommand.h
+++ b/Source/cmBreakCommand.h
@@ -25,24 +25,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmBreakCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmBreakCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "break"; }
+  std::string GetName() const CM_OVERRIDE { return "break"; }
 
   cmTypeMacro(cmBreakCommand, cmCommand);
 };
diff --git a/Source/cmBuildCommand.h b/Source/cmBuildCommand.h
index 6cbf3ca..552e5ff 100644
--- a/Source/cmBuildCommand.h
+++ b/Source/cmBuildCommand.h
@@ -25,14 +25,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmBuildCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmBuildCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The primary command signature with optional, KEYWORD-based args.
@@ -47,7 +47,7 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "build_command"; }
+  std::string GetName() const CM_OVERRIDE { return "build_command"; }
 
   cmTypeMacro(cmBuildCommand, cmCommand);
 
diff --git a/Source/cmBuildNameCommand.h b/Source/cmBuildNameCommand.h
index 43c24b0..4a1641bd 100644
--- a/Source/cmBuildNameCommand.h
+++ b/Source/cmBuildNameCommand.h
@@ -18,11 +18,11 @@ class cmBuildNameCommand : public cmCommand
 {
 public:
   cmTypeMacro(cmBuildNameCommand, cmCommand);
-  virtual cmCommand* Clone() { return new cmBuildNameCommand; }
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
-  virtual std::string GetName() const { return "build_name"; }
-  virtual bool IsScriptable() const { return true; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmBuildNameCommand; }
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
+  std::string GetName() const CM_OVERRIDE { return "build_name"; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 };
 
 #endif
diff --git a/Source/cmCMakeHostSystemInformationCommand.h b/Source/cmCMakeHostSystemInformationCommand.h
index 6981ea9..8e6f0f5 100644
--- a/Source/cmCMakeHostSystemInformationCommand.h
+++ b/Source/cmCMakeHostSystemInformationCommand.h
@@ -28,7 +28,7 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     return new cmCMakeHostSystemInformationCommand;
   }
@@ -37,18 +37,18 @@ public:
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
   * This determines if the command is invoked when in script mode.
   */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
   * The name of the command as specified in CMakeList.txt.
   */
-  virtual std::string GetName() const
+  std::string GetName() const CM_OVERRIDE
   {
     return "cmake_host_system_information";
   }
diff --git a/Source/cmCMakeMinimumRequired.h b/Source/cmCMakeMinimumRequired.h
index fc73e87..4231eb4 100644
--- a/Source/cmCMakeMinimumRequired.h
+++ b/Source/cmCMakeMinimumRequired.h
@@ -25,24 +25,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmCMakeMinimumRequired; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmCMakeMinimumRequired; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "cmake_minimum_required"; }
+  std::string GetName() const CM_OVERRIDE { return "cmake_minimum_required"; }
 
   cmTypeMacro(cmCMakeMinimumRequired, cmCommand);
 
diff --git a/Source/cmCMakePolicyCommand.h b/Source/cmCMakePolicyCommand.h
index dbb91d5..fd4ab0a 100644
--- a/Source/cmCMakePolicyCommand.h
+++ b/Source/cmCMakePolicyCommand.h
@@ -26,24 +26,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmCMakePolicyCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmCMakePolicyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
     * This determines if the command is invoked when in script mode.
     */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
     * The name of the command as specified in CMakeList.txt.
     */
-  virtual std::string GetName() const { return "cmake_policy"; }
+  std::string GetName() const CM_OVERRIDE { return "cmake_policy"; }
 
   cmTypeMacro(cmCMakePolicyCommand, cmCommand);
 
diff --git a/Source/cmCPackPropertiesGenerator.h b/Source/cmCPackPropertiesGenerator.h
index 4372b87..4d092f6 100644
--- a/Source/cmCPackPropertiesGenerator.h
+++ b/Source/cmCPackPropertiesGenerator.h
@@ -29,9 +29,8 @@ public:
                              std::vector<std::string> const& configurations);
 
 protected:
-  virtual void GenerateScriptForConfig(std::ostream& os,
-                                       const std::string& config,
-                                       Indent const& indent);
+  void GenerateScriptForConfig(std::ostream& os, const std::string& config,
+                               Indent const& indent) CM_OVERRIDE;
 
   cmLocalGenerator* LG;
   cmInstalledFile const& InstalledFile;
diff --git a/Source/cmCommand.h b/Source/cmCommand.h
index 0157293..be90a46 100644
--- a/Source/cmCommand.h
+++ b/Source/cmCommand.h
@@ -45,7 +45,7 @@ public:
   /**
    * Need virtual destructor to destroy real command type.
    */
-  virtual ~cmCommand() {}
+  ~cmCommand() CM_OVERRIDE {}
 
   /**
    * Specify the makefile.
diff --git a/Source/cmCommandArgumentsHelper.h b/Source/cmCommandArgumentsHelper.h
index c2a6f92..27fef1f 100644
--- a/Source/cmCommandArgumentsHelper.h
+++ b/Source/cmCommandArgumentsHelper.h
@@ -108,8 +108,8 @@ private:
   unsigned int DataStart;
   const char* Ignore;
   cmCAStringVector();
-  virtual bool DoConsume(const std::string& arg, unsigned int index);
-  virtual void DoReset();
+  bool DoConsume(const std::string& arg, unsigned int index) CM_OVERRIDE;
+  void DoReset() CM_OVERRIDE;
 };
 
 /** cmCAString is to be used for arguments which consist of one value,
@@ -126,8 +126,8 @@ public:
 private:
   std::string String;
   unsigned int DataStart;
-  virtual bool DoConsume(const std::string& arg, unsigned int index);
-  virtual void DoReset();
+  bool DoConsume(const std::string& arg, unsigned int index) CM_OVERRIDE;
+  void DoReset() CM_OVERRIDE;
   cmCAString();
 };
 
@@ -143,8 +143,8 @@ public:
   bool IsEnabled() const { return this->Enabled; }
 private:
   bool Enabled;
-  virtual bool DoConsume(const std::string& arg, unsigned int index);
-  virtual void DoReset();
+  bool DoConsume(const std::string& arg, unsigned int index) CM_OVERRIDE;
+  void DoReset() CM_OVERRIDE;
   cmCAEnabler();
 };
 
@@ -160,8 +160,8 @@ public:
   bool IsEnabled() const { return this->Enabled; }
 private:
   bool Enabled;
-  virtual bool DoConsume(const std::string& arg, unsigned int index);
-  virtual void DoReset();
+  bool DoConsume(const std::string& arg, unsigned int index) CM_OVERRIDE;
+  void DoReset() CM_OVERRIDE;
   cmCADisabler();
 };
 
diff --git a/Source/cmConfigureFileCommand.h b/Source/cmConfigureFileCommand.h
index 79f00bc..1da65c8 100644
--- a/Source/cmConfigureFileCommand.h
+++ b/Source/cmConfigureFileCommand.h
@@ -19,24 +19,24 @@ class cmConfigureFileCommand : public cmCommand
 public:
   cmTypeMacro(cmConfigureFileCommand, cmCommand);
 
-  virtual cmCommand* Clone() { return new cmConfigureFileCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmConfigureFileCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "configure_file"; }
+  std::string GetName() const CM_OVERRIDE { return "configure_file"; }
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
 private:
   int ConfigureFile();
diff --git a/Source/cmContinueCommand.h b/Source/cmContinueCommand.h
index 63ae59d..6fa9af2 100644
--- a/Source/cmContinueCommand.h
+++ b/Source/cmContinueCommand.h
@@ -25,24 +25,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmContinueCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmContinueCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "continue"; }
+  std::string GetName() const CM_OVERRIDE { return "continue"; }
 
   cmTypeMacro(cmContinueCommand, cmCommand);
 };
diff --git a/Source/cmCreateTestSourceList.h b/Source/cmCreateTestSourceList.h
index cfaca2e..2025ecd 100644
--- a/Source/cmCreateTestSourceList.h
+++ b/Source/cmCreateTestSourceList.h
@@ -25,19 +25,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmCreateTestSourceList; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmCreateTestSourceList; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "create_test_sourcelist"; }
+  std::string GetName() const CM_OVERRIDE { return "create_test_sourcelist"; }
 
   cmTypeMacro(cmCreateTestSourceList, cmCommand);
 };
diff --git a/Source/cmCryptoHash.h b/Source/cmCryptoHash.h
index a0c5eab..85adf69 100644
--- a/Source/cmCryptoHash.h
+++ b/Source/cmCryptoHash.h
@@ -36,12 +36,12 @@ class cmCryptoHashMD5 : public cmCryptoHash
 
 public:
   cmCryptoHashMD5();
-  ~cmCryptoHashMD5();
+  ~cmCryptoHashMD5() CM_OVERRIDE;
 
 protected:
-  virtual void Initialize();
-  virtual void Append(unsigned char const* buf, int sz);
-  virtual std::string Finalize();
+  void Initialize() CM_OVERRIDE;
+  void Append(unsigned char const* buf, int sz) CM_OVERRIDE;
+  std::string Finalize() CM_OVERRIDE;
 };
 
 #define cmCryptoHash_SHA_CLASS_DECL(SHA)                                      \
diff --git a/Source/cmDefinePropertyCommand.h b/Source/cmDefinePropertyCommand.h
index 4248bbe..9cc19c4 100644
--- a/Source/cmDefinePropertyCommand.h
+++ b/Source/cmDefinePropertyCommand.h
@@ -17,19 +17,19 @@
 class cmDefinePropertyCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone() { return new cmDefinePropertyCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmDefinePropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "define_property"; }
+  std::string GetName() const CM_OVERRIDE { return "define_property"; }
 
   cmTypeMacro(cmDefinePropertyCommand, cmCommand);
 
diff --git a/Source/cmDependsC.h b/Source/cmDependsC.h
index e830aa8..bde07b7 100644
--- a/Source/cmDependsC.h
+++ b/Source/cmDependsC.h
@@ -31,14 +31,13 @@ public:
              const std::map<std::string, DependencyVector>* validDeps);
 
   /** Virtual destructor to cleanup subclasses properly.  */
-  virtual ~cmDependsC();
+  ~cmDependsC() CM_OVERRIDE;
 
 protected:
   // Implement writing/checking methods required by superclass.
-  virtual bool WriteDependencies(const std::set<std::string>& sources,
-                                 const std::string& obj,
-                                 std::ostream& makeDepends,
-                                 std::ostream& internalDepends);
+  bool WriteDependencies(const std::set<std::string>& sources,
+                         const std::string& obj, std::ostream& makeDepends,
+                         std::ostream& internalDepends) CM_OVERRIDE;
 
   // Method to scan a single file.
   void Scan(std::istream& is, const char* directory,
diff --git a/Source/cmDependsFortran.h b/Source/cmDependsFortran.h
index 5ff0b6c..f4385eb 100644
--- a/Source/cmDependsFortran.h
+++ b/Source/cmDependsFortran.h
@@ -34,7 +34,7 @@ public:
   cmDependsFortran(cmLocalGenerator* lg);
 
   /** Virtual destructor to cleanup subclasses properly.  */
-  virtual ~cmDependsFortran();
+  ~cmDependsFortran() CM_OVERRIDE;
 
   /** Callback from build system after a .mod file has been generated
       by a Fortran90 compiler to copy the .mod file to the
@@ -48,8 +48,8 @@ public:
 
 protected:
   // Finalize the dependency information for the target.
-  virtual bool Finalize(std::ostream& makeDepends,
-                        std::ostream& internalDepends);
+  bool Finalize(std::ostream& makeDepends,
+                std::ostream& internalDepends) CM_OVERRIDE;
 
   // Find all the modules required by the target.
   void LocateModules();
@@ -59,10 +59,9 @@ protected:
   bool FindModule(std::string const& name, std::string& module);
 
   // Implement writing/checking methods required by superclass.
-  virtual bool WriteDependencies(const std::set<std::string>& sources,
-                                 const std::string& file,
-                                 std::ostream& makeDepends,
-                                 std::ostream& internalDepends);
+  bool WriteDependencies(const std::set<std::string>& sources,
+                         const std::string& file, std::ostream& makeDepends,
+                         std::ostream& internalDepends) CM_OVERRIDE;
 
   // Actually write the depenencies to the streams.
   bool WriteDependenciesReal(const char* obj, cmFortranSourceInfo const& info,
diff --git a/Source/cmDependsJava.h b/Source/cmDependsJava.h
index 44723fa..5bb3039 100644
--- a/Source/cmDependsJava.h
+++ b/Source/cmDependsJava.h
@@ -25,17 +25,16 @@ public:
   cmDependsJava();
 
   /** Virtual destructor to cleanup subclasses properly.  */
-  virtual ~cmDependsJava();
+  ~cmDependsJava() CM_OVERRIDE;
 
 protected:
   // Implement writing/checking methods required by superclass.
-  virtual bool WriteDependencies(const std::set<std::string>& sources,
-                                 const std::string& file,
-                                 std::ostream& makeDepends,
-                                 std::ostream& internalDepends);
-  virtual bool CheckDependencies(
+  bool WriteDependencies(const std::set<std::string>& sources,
+                         const std::string& file, std::ostream& makeDepends,
+                         std::ostream& internalDepends) CM_OVERRIDE;
+  bool CheckDependencies(
     std::istream& internalDepends, const char* internalDependsFileName,
-    std::map<std::string, DependencyVector>& validDeps);
+    std::map<std::string, DependencyVector>& validDeps) CM_OVERRIDE;
 
 private:
   cmDependsJava(cmDependsJava const&);  // Purposely not implemented.
diff --git a/Source/cmElseCommand.h b/Source/cmElseCommand.h
index 815825e..9acf4d8 100644
--- a/Source/cmElseCommand.h
+++ b/Source/cmElseCommand.h
@@ -25,24 +25,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmElseCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmElseCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "else"; }
+  std::string GetName() const CM_OVERRIDE { return "else"; }
 
   cmTypeMacro(cmElseCommand, cmCommand);
 };
diff --git a/Source/cmElseIfCommand.h b/Source/cmElseIfCommand.h
index d0ffa5d..19c1885 100644
--- a/Source/cmElseIfCommand.h
+++ b/Source/cmElseIfCommand.h
@@ -25,24 +25,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmElseIfCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmElseIfCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "elseif"; }
+  std::string GetName() const CM_OVERRIDE { return "elseif"; }
 
   cmTypeMacro(cmElseIfCommand, cmCommand);
 };
diff --git a/Source/cmEnableLanguageCommand.h b/Source/cmEnableLanguageCommand.h
index 657e4e5..31b6095 100644
--- a/Source/cmEnableLanguageCommand.h
+++ b/Source/cmEnableLanguageCommand.h
@@ -28,19 +28,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmEnableLanguageCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmEnableLanguageCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "enable_language"; }
+  std::string GetName() const CM_OVERRIDE { return "enable_language"; }
 
   cmTypeMacro(cmEnableLanguageCommand, cmCommand);
 };
diff --git a/Source/cmEnableTestingCommand.h b/Source/cmEnableTestingCommand.h
index a518f18..8c8ffbf 100644
--- a/Source/cmEnableTestingCommand.h
+++ b/Source/cmEnableTestingCommand.h
@@ -33,19 +33,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmEnableTestingCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmEnableTestingCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const&,
-                           cmExecutionStatus&);
+  bool InitialPass(std::vector<std::string> const&,
+                   cmExecutionStatus&) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "enable_testing"; }
+  std::string GetName() const CM_OVERRIDE { return "enable_testing"; }
 
   cmTypeMacro(cmEnableTestingCommand, cmCommand);
 };
diff --git a/Source/cmEndForEachCommand.h b/Source/cmEndForEachCommand.h
index ebc794f..b2c47b2 100644
--- a/Source/cmEndForEachCommand.h
+++ b/Source/cmEndForEachCommand.h
@@ -25,20 +25,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmEndForEachCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmEndForEachCommand; }
 
   /**
    * Override cmCommand::InvokeInitialPass to get arguments before
    * expansion.
    */
-  virtual bool InvokeInitialPass(std::vector<cmListFileArgument> const&,
-                                 cmExecutionStatus&);
+  bool InvokeInitialPass(std::vector<cmListFileArgument> const&,
+                         cmExecutionStatus&) CM_OVERRIDE;
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  bool InitialPass(std::vector<std::string> const&,
+                   cmExecutionStatus&) CM_OVERRIDE
   {
     return false;
   }
@@ -46,12 +47,12 @@ public:
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "endforeach"; }
+  std::string GetName() const CM_OVERRIDE { return "endforeach"; }
 
   cmTypeMacro(cmEndForEachCommand, cmCommand);
 };
diff --git a/Source/cmEndFunctionCommand.h b/Source/cmEndFunctionCommand.h
index b69dec0..856fdc5 100644
--- a/Source/cmEndFunctionCommand.h
+++ b/Source/cmEndFunctionCommand.h
@@ -25,20 +25,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmEndFunctionCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmEndFunctionCommand; }
 
   /**
    * Override cmCommand::InvokeInitialPass to get arguments before
    * expansion.
    */
-  virtual bool InvokeInitialPass(std::vector<cmListFileArgument> const&,
-                                 cmExecutionStatus&);
+  bool InvokeInitialPass(std::vector<cmListFileArgument> const&,
+                         cmExecutionStatus&) CM_OVERRIDE;
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  bool InitialPass(std::vector<std::string> const&,
+                   cmExecutionStatus&) CM_OVERRIDE
   {
     return false;
   }
@@ -46,12 +47,12 @@ public:
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "endfunction"; }
+  std::string GetName() const CM_OVERRIDE { return "endfunction"; }
 
   cmTypeMacro(cmEndFunctionCommand, cmCommand);
 };
diff --git a/Source/cmEndIfCommand.h b/Source/cmEndIfCommand.h
index 457dfd3..13cf6f6 100644
--- a/Source/cmEndIfCommand.h
+++ b/Source/cmEndIfCommand.h
@@ -25,24 +25,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmEndIfCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmEndIfCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "endif"; }
+  std::string GetName() const CM_OVERRIDE { return "endif"; }
 
   cmTypeMacro(cmEndIfCommand, cmCommand);
 };
diff --git a/Source/cmEndMacroCommand.h b/Source/cmEndMacroCommand.h
index 615e8dc..e176eaf 100644
--- a/Source/cmEndMacroCommand.h
+++ b/Source/cmEndMacroCommand.h
@@ -25,20 +25,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmEndMacroCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmEndMacroCommand; }
 
   /**
    * Override cmCommand::InvokeInitialPass to get arguments before
    * expansion.
    */
-  virtual bool InvokeInitialPass(std::vector<cmListFileArgument> const&,
-                                 cmExecutionStatus&);
+  bool InvokeInitialPass(std::vector<cmListFileArgument> const&,
+                         cmExecutionStatus&) CM_OVERRIDE;
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  bool InitialPass(std::vector<std::string> const&,
+                   cmExecutionStatus&) CM_OVERRIDE
   {
     return false;
   }
@@ -46,12 +47,12 @@ public:
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "endmacro"; }
+  std::string GetName() const CM_OVERRIDE { return "endmacro"; }
 
   cmTypeMacro(cmEndMacroCommand, cmCommand);
 };
diff --git a/Source/cmEndWhileCommand.h b/Source/cmEndWhileCommand.h
index 5eda7af..6b72514 100644
--- a/Source/cmEndWhileCommand.h
+++ b/Source/cmEndWhileCommand.h
@@ -25,20 +25,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmEndWhileCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmEndWhileCommand; }
 
   /**
    * Override cmCommand::InvokeInitialPass to get arguments before
    * expansion.
    */
-  virtual bool InvokeInitialPass(std::vector<cmListFileArgument> const& args,
-                                 cmExecutionStatus& status);
+  bool InvokeInitialPass(std::vector<cmListFileArgument> const& args,
+                         cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  bool InitialPass(std::vector<std::string> const&,
+                   cmExecutionStatus&) CM_OVERRIDE
   {
     return false;
   }
@@ -46,12 +47,12 @@ public:
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "endwhile"; }
+  std::string GetName() const CM_OVERRIDE { return "endwhile"; }
 
   cmTypeMacro(cmEndWhileCommand, cmCommand);
 };
diff --git a/Source/cmExecProgramCommand.h b/Source/cmExecProgramCommand.h
index e6e76d2..ef87aac 100644
--- a/Source/cmExecProgramCommand.h
+++ b/Source/cmExecProgramCommand.h
@@ -27,24 +27,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmExecProgramCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmExecProgramCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "exec_program"; }
+  std::string GetName() const CM_OVERRIDE { return "exec_program"; }
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   cmTypeMacro(cmExecProgramCommand, cmCommand);
 
diff --git a/Source/cmExecuteProcessCommand.h b/Source/cmExecuteProcessCommand.h
index a89e705..61687ef 100644
--- a/Source/cmExecuteProcessCommand.h
+++ b/Source/cmExecuteProcessCommand.h
@@ -26,24 +26,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmExecuteProcessCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmExecuteProcessCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "execute_process"; }
+  std::string GetName() const CM_OVERRIDE { return "execute_process"; }
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   cmTypeMacro(cmExecuteProcessCommand, cmCommand);
 };
diff --git a/Source/cmExportBuildFileGenerator.h b/Source/cmExportBuildFileGenerator.h
index be3c70a..417e8c9 100644
--- a/Source/cmExportBuildFileGenerator.h
+++ b/Source/cmExportBuildFileGenerator.h
@@ -50,14 +50,14 @@ public:
 
 protected:
   // Implement virtual methods from the superclass.
-  virtual bool GenerateMainFile(std::ostream& os);
-  virtual void GenerateImportTargetsConfig(
+  bool GenerateMainFile(std::ostream& os) CM_OVERRIDE;
+  void GenerateImportTargetsConfig(
     std::ostream& os, const std::string& config, std::string const& suffix,
-    std::vector<std::string>& missingTargets);
-  virtual void HandleMissingTarget(std::string& link_libs,
-                                   std::vector<std::string>& missingTargets,
-                                   cmGeneratorTarget* depender,
-                                   cmGeneratorTarget* dependee);
+    std::vector<std::string>& missingTargets) CM_OVERRIDE;
+  void HandleMissingTarget(std::string& link_libs,
+                           std::vector<std::string>& missingTargets,
+                           cmGeneratorTarget* depender,
+                           cmGeneratorTarget* dependee) CM_OVERRIDE;
 
   void ComplainAboutMissingTarget(cmGeneratorTarget* depender,
                                   cmGeneratorTarget* dependee,
@@ -70,7 +70,7 @@ protected:
                                  ImportPropertyMap& properties);
 
   std::string InstallNameDir(cmGeneratorTarget* target,
-                             const std::string& config);
+                             const std::string& config) CM_OVERRIDE;
 
   std::vector<std::string> FindNamespaces(cmGlobalGenerator* gg,
                                           const std::string& name);
diff --git a/Source/cmExportCommand.h b/Source/cmExportCommand.h
index a71393a..0a149af 100644
--- a/Source/cmExportCommand.h
+++ b/Source/cmExportCommand.h
@@ -30,19 +30,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmExportCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmExportCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "export"; }
+  std::string GetName() const CM_OVERRIDE { return "export"; }
 
   cmTypeMacro(cmExportCommand, cmCommand);
 
diff --git a/Source/cmExportInstallFileGenerator.h b/Source/cmExportInstallFileGenerator.h
index 723b6e5..68960db 100644
--- a/Source/cmExportInstallFileGenerator.h
+++ b/Source/cmExportInstallFileGenerator.h
@@ -52,16 +52,16 @@ public:
 
 protected:
   // Implement virtual methods from the superclass.
-  virtual bool GenerateMainFile(std::ostream& os);
-  virtual void GenerateImportTargetsConfig(
+  bool GenerateMainFile(std::ostream& os) CM_OVERRIDE;
+  void GenerateImportTargetsConfig(
     std::ostream& os, const std::string& config, std::string const& suffix,
-    std::vector<std::string>& missingTargets);
-  virtual void HandleMissingTarget(std::string& link_libs,
-                                   std::vector<std::string>& missingTargets,
-                                   cmGeneratorTarget* depender,
-                                   cmGeneratorTarget* dependee);
+    std::vector<std::string>& missingTargets) CM_OVERRIDE;
+  void HandleMissingTarget(std::string& link_libs,
+                           std::vector<std::string>& missingTargets,
+                           cmGeneratorTarget* depender,
+                           cmGeneratorTarget* dependee) CM_OVERRIDE;
 
-  virtual void ReplaceInstallPrefix(std::string& input);
+  void ReplaceInstallPrefix(std::string& input) CM_OVERRIDE;
 
   void ComplainAboutMissingTarget(cmGeneratorTarget* depender,
                                   cmGeneratorTarget* dependee,
@@ -82,7 +82,7 @@ protected:
                                  std::set<std::string>& importedLocations);
 
   std::string InstallNameDir(cmGeneratorTarget* target,
-                             const std::string& config);
+                             const std::string& config) CM_OVERRIDE;
 
   cmInstallExportGenerator* IEGen;
 
diff --git a/Source/cmExportLibraryDependenciesCommand.h b/Source/cmExportLibraryDependenciesCommand.h
index 3fb3565..4b3dc92 100644
--- a/Source/cmExportLibraryDependenciesCommand.h
+++ b/Source/cmExportLibraryDependenciesCommand.h
@@ -18,13 +18,19 @@ class cmExportLibraryDependenciesCommand : public cmCommand
 {
 public:
   cmTypeMacro(cmExportLibraryDependenciesCommand, cmCommand);
-  virtual cmCommand* Clone() { return new cmExportLibraryDependenciesCommand; }
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
-  virtual std::string GetName() const { return "export_library_dependencies"; }
+  cmCommand* Clone() CM_OVERRIDE
+  {
+    return new cmExportLibraryDependenciesCommand;
+  }
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
+  std::string GetName() const CM_OVERRIDE
+  {
+    return "export_library_dependencies";
+  }
 
-  virtual void FinalPass();
-  virtual bool HasFinalPass() const { return true; }
+  void FinalPass() CM_OVERRIDE;
+  bool HasFinalPass() const CM_OVERRIDE { return true; }
 
 private:
   std::string Filename;
diff --git a/Source/cmExportTryCompileFileGenerator.h b/Source/cmExportTryCompileFileGenerator.h
index 26f4db1..1d13711 100644
--- a/Source/cmExportTryCompileFileGenerator.h
+++ b/Source/cmExportTryCompileFileGenerator.h
@@ -28,15 +28,15 @@ public:
   void SetConfig(const std::string& config) { this->Config = config; }
 protected:
   // Implement virtual methods from the superclass.
-  virtual bool GenerateMainFile(std::ostream& os);
+  bool GenerateMainFile(std::ostream& os) CM_OVERRIDE;
 
-  virtual void GenerateImportTargetsConfig(std::ostream&, const std::string&,
-                                           std::string const&,
-                                           std::vector<std::string>&)
+  void GenerateImportTargetsConfig(std::ostream&, const std::string&,
+                                   std::string const&,
+                                   std::vector<std::string>&) CM_OVERRIDE
   {
   }
-  virtual void HandleMissingTarget(std::string&, std::vector<std::string>&,
-                                   cmGeneratorTarget*, cmGeneratorTarget*)
+  void HandleMissingTarget(std::string&, std::vector<std::string>&,
+                           cmGeneratorTarget*, cmGeneratorTarget*) CM_OVERRIDE
   {
   }
 
@@ -45,7 +45,7 @@ protected:
                           std::set<const cmGeneratorTarget*>& emitted);
 
   std::string InstallNameDir(cmGeneratorTarget* target,
-                             const std::string& config);
+                             const std::string& config) CM_OVERRIDE;
 
 private:
   std::string FindTargets(const std::string& prop,
diff --git a/Source/cmExtraCodeBlocksGenerator.h b/Source/cmExtraCodeBlocksGenerator.h
index fe4f513..31ea500 100644
--- a/Source/cmExtraCodeBlocksGenerator.h
+++ b/Source/cmExtraCodeBlocksGenerator.h
@@ -28,7 +28,7 @@ class cmExtraCodeBlocksGenerator : public cmExternalMakefileProjectGenerator
 public:
   cmExtraCodeBlocksGenerator();
 
-  virtual std::string GetName() const
+  std::string GetName() const CM_OVERRIDE
   {
     return cmExtraCodeBlocksGenerator::GetActualName();
   }
@@ -38,10 +38,10 @@ public:
     return new cmExtraCodeBlocksGenerator;
   }
   /** Get the documentation entry for this generator.  */
-  virtual void GetDocumentation(cmDocumentationEntry& entry,
-                                const std::string& fullName) const;
+  void GetDocumentation(cmDocumentationEntry& entry,
+                        const std::string& fullName) const CM_OVERRIDE;
 
-  virtual void Generate();
+  void Generate() CM_OVERRIDE;
 
 private:
   struct CbpUnit
diff --git a/Source/cmExtraCodeLiteGenerator.h b/Source/cmExtraCodeLiteGenerator.h
index 01ff31f..f2ee85c 100644
--- a/Source/cmExtraCodeLiteGenerator.h
+++ b/Source/cmExtraCodeLiteGenerator.h
@@ -36,7 +36,7 @@ protected:
 public:
   cmExtraCodeLiteGenerator();
 
-  virtual std::string GetName() const
+  std::string GetName() const CM_OVERRIDE
   {
     return cmExtraCodeLiteGenerator::GetActualName();
   }
@@ -46,10 +46,10 @@ public:
     return new cmExtraCodeLiteGenerator;
   }
   /** Get the documentation entry for this generator.  */
-  virtual void GetDocumentation(cmDocumentationEntry& entry,
-                                const std::string& fullName) const;
+  void GetDocumentation(cmDocumentationEntry& entry,
+                        const std::string& fullName) const CM_OVERRIDE;
 
-  virtual void Generate();
+  void Generate() CM_OVERRIDE;
   void CreateProjectFile(const std::vector<cmLocalGenerator*>& lgs);
 
   void CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs,
diff --git a/Source/cmExtraEclipseCDT4Generator.h b/Source/cmExtraEclipseCDT4Generator.h
index 0cef071..ff6e4b6 100644
--- a/Source/cmExtraEclipseCDT4Generator.h
+++ b/Source/cmExtraEclipseCDT4Generator.h
@@ -40,19 +40,19 @@ public:
     return new cmExtraEclipseCDT4Generator;
   }
 
-  virtual std::string GetName() const
+  std::string GetName() const CM_OVERRIDE
   {
     return cmExtraEclipseCDT4Generator::GetActualName();
   }
 
   static std::string GetActualName() { return "Eclipse CDT4"; }
 
-  virtual void GetDocumentation(cmDocumentationEntry& entry,
-                                const std::string& fullName) const;
-  virtual void EnableLanguage(std::vector<std::string> const& languages,
-                              cmMakefile*, bool optional);
+  void GetDocumentation(cmDocumentationEntry& entry,
+                        const std::string& fullName) const CM_OVERRIDE;
+  void EnableLanguage(std::vector<std::string> const& languages, cmMakefile*,
+                      bool optional) CM_OVERRIDE;
 
-  virtual void Generate();
+  void Generate() CM_OVERRIDE;
 
 private:
   // create .project file in the source tree
diff --git a/Source/cmExtraKateGenerator.h b/Source/cmExtraKateGenerator.h
index 71e88a9..410d552 100644
--- a/Source/cmExtraKateGenerator.h
+++ b/Source/cmExtraKateGenerator.h
@@ -26,7 +26,7 @@ class cmExtraKateGenerator : public cmExternalMakefileProjectGenerator
 public:
   cmExtraKateGenerator();
 
-  virtual std::string GetName() const
+  std::string GetName() const CM_OVERRIDE
   {
     return cmExtraKateGenerator::GetActualName();
   }
@@ -36,10 +36,10 @@ public:
     return new cmExtraKateGenerator;
   }
   /** Get the documentation entry for this generator.  */
-  virtual void GetDocumentation(cmDocumentationEntry& entry,
-                                const std::string& fullName) const;
+  void GetDocumentation(cmDocumentationEntry& entry,
+                        const std::string& fullName) const CM_OVERRIDE;
 
-  virtual void Generate();
+  void Generate() CM_OVERRIDE;
 
 private:
   void CreateKateProjectFile(const cmLocalGenerator* lg) const;
diff --git a/Source/cmExtraSublimeTextGenerator.h b/Source/cmExtraSublimeTextGenerator.h
index 6efec7a..26dd138 100644
--- a/Source/cmExtraSublimeTextGenerator.h
+++ b/Source/cmExtraSublimeTextGenerator.h
@@ -30,7 +30,7 @@ public:
   typedef std::map<std::string, std::vector<std::string> > MapSourceFileFlags;
   cmExtraSublimeTextGenerator();
 
-  virtual std::string GetName() const
+  std::string GetName() const CM_OVERRIDE
   {
     return cmExtraSublimeTextGenerator::GetActualName();
   }
@@ -40,10 +40,10 @@ public:
     return new cmExtraSublimeTextGenerator;
   }
   /** Get the documentation entry for this generator.  */
-  virtual void GetDocumentation(cmDocumentationEntry& entry,
-                                const std::string& fullName) const;
+  void GetDocumentation(cmDocumentationEntry& entry,
+                        const std::string& fullName) const CM_OVERRIDE;
 
-  virtual void Generate();
+  void Generate() CM_OVERRIDE;
 
 private:
   void CreateProjectFile(const std::vector<cmLocalGenerator*>& lgs);
diff --git a/Source/cmFLTKWrapUICommand.h b/Source/cmFLTKWrapUICommand.h
index 2e60051..72b468e 100644
--- a/Source/cmFLTKWrapUICommand.h
+++ b/Source/cmFLTKWrapUICommand.h
@@ -28,14 +28,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmFLTKWrapUICommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmFLTKWrapUICommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This is called at the end after all the information
@@ -43,13 +43,13 @@ public:
    * not implement this method.  At this point, reading and
    * writing to the cache can be done.
    */
-  virtual void FinalPass();
-  virtual bool HasFinalPass() const { return true; }
+  void FinalPass() CM_OVERRIDE;
+  bool HasFinalPass() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "fltk_wrap_ui"; }
+  std::string GetName() const CM_OVERRIDE { return "fltk_wrap_ui"; }
 
 private:
   /**
diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx
index 6abc238..c1fca51 100644
--- a/Source/cmFileCommand.cxx
+++ b/Source/cmFileCommand.cxx
@@ -1615,7 +1615,7 @@ struct cmFileInstaller : public cmFileCopier
     this->Manifest =
       this->Makefile->GetSafeDefinition("CMAKE_INSTALL_MANIFEST_FILES");
   }
-  ~cmFileInstaller()
+  ~cmFileInstaller() CM_OVERRIDE
   {
     // Save the updated install manifest.
     this->Makefile->AddDefinition("CMAKE_INSTALL_MANIFEST_FILES",
@@ -1640,12 +1640,12 @@ protected:
     this->Manifest += file.substr(this->DestDirLength);
   }
 
-  virtual std::string const& ToName(std::string const& fromName)
+  std::string const& ToName(std::string const& fromName) CM_OVERRIDE
   {
     return this->Rename.empty() ? fromName : this->Rename;
   }
 
-  virtual void ReportCopy(const char* toFile, Type type, bool copy)
+  void ReportCopy(const char* toFile, Type type, bool copy) CM_OVERRIDE
   {
     if (!this->MessageNever && (copy || !this->MessageLazy)) {
       std::string message = (copy ? "Installing: " : "Up-to-date: ");
@@ -1657,11 +1657,11 @@ protected:
       this->ManifestAppend(toFile);
     }
   }
-  virtual bool ReportMissing(const char* fromFile)
+  bool ReportMissing(const char* fromFile) CM_OVERRIDE
   {
     return (this->Optional || this->cmFileCopier::ReportMissing(fromFile));
   }
-  virtual bool Install(const char* fromFile, const char* toFile)
+  bool Install(const char* fromFile, const char* toFile) CM_OVERRIDE
   {
     // Support installing from empty source to make a directory.
     if (this->InstallType == cmInstallType_DIRECTORY && !*fromFile) {
@@ -1670,16 +1670,16 @@ protected:
     return this->cmFileCopier::Install(fromFile, toFile);
   }
 
-  virtual bool Parse(std::vector<std::string> const& args);
+  bool Parse(std::vector<std::string> const& args) CM_OVERRIDE;
   enum
   {
     DoingType = DoingLast1,
     DoingRename,
     DoingLast2
   };
-  virtual bool CheckKeyword(std::string const& arg);
-  virtual bool CheckValue(std::string const& arg);
-  virtual void DefaultFilePermissions()
+  bool CheckKeyword(std::string const& arg) CM_OVERRIDE;
+  bool CheckValue(std::string const& arg) CM_OVERRIDE;
+  void DefaultFilePermissions() CM_OVERRIDE
   {
     this->cmFileCopier::DefaultFilePermissions();
     // Add execute permissions based on the target type.
diff --git a/Source/cmFileCommand.h b/Source/cmFileCommand.h
index 84bb456..9121d3c 100644
--- a/Source/cmFileCommand.h
+++ b/Source/cmFileCommand.h
@@ -26,24 +26,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmFileCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmFileCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "file"; }
+  std::string GetName() const CM_OVERRIDE { return "file"; }
 
   cmTypeMacro(cmFileCommand, cmCommand);
 
diff --git a/Source/cmFindCommon.h b/Source/cmFindCommon.h
index ebec884..0f8d826 100644
--- a/Source/cmFindCommon.h
+++ b/Source/cmFindCommon.h
@@ -27,7 +27,7 @@ class cmFindCommon : public cmCommand
 {
 public:
   cmFindCommon();
-  ~cmFindCommon();
+  ~cmFindCommon() CM_OVERRIDE;
   cmTypeMacro(cmFindCommon, cmCommand);
 
 protected:
diff --git a/Source/cmFindFileCommand.h b/Source/cmFindFileCommand.h
index 74b01f1..68bd5b9 100644
--- a/Source/cmFindFileCommand.h
+++ b/Source/cmFindFileCommand.h
@@ -29,8 +29,8 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmFindFileCommand; }
-  virtual std::string GetName() const { return "find_file"; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmFindFileCommand; }
+  std::string GetName() const CM_OVERRIDE { return "find_file"; }
 
   cmTypeMacro(cmFindFileCommand, cmFindPathCommand);
 };
diff --git a/Source/cmFindLibraryCommand.h b/Source/cmFindLibraryCommand.h
index a08e151..813decd 100644
--- a/Source/cmFindLibraryCommand.h
+++ b/Source/cmFindLibraryCommand.h
@@ -28,24 +28,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmFindLibraryCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmFindLibraryCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "find_library"; }
+  std::string GetName() const CM_OVERRIDE { return "find_library"; }
 
   cmTypeMacro(cmFindLibraryCommand, cmFindBase);
 
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index d074b05..c133fcf 100644
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@@ -1566,7 +1566,7 @@ public:
   }
 
 private:
-  bool Visit(std::string const& fullPath)
+  bool Visit(std::string const& fullPath) CM_OVERRIDE
   {
     if (this->UseSuffixes) {
       return this->FPC->SearchDirectory(fullPath);
@@ -1616,12 +1616,12 @@ public:
 
 private:
   std::string String;
-  virtual bool Search(std::string const& parent, cmFileList& lister)
+  bool Search(std::string const& parent, cmFileList& lister) CM_OVERRIDE
   {
     std::string fullPath = parent + this->String;
     return this->Consider(fullPath, lister);
   }
-  virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const
+  cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
   {
     cmsys::auto_ptr<cmFileListGeneratorBase> g(
       new cmFileListGeneratorFixed(*this));
@@ -1645,7 +1645,7 @@ public:
 
 private:
   std::vector<std::string> const& Vector;
-  virtual bool Search(std::string const& parent, cmFileList& lister)
+  bool Search(std::string const& parent, cmFileList& lister) CM_OVERRIDE
   {
     for (std::vector<std::string>::const_iterator i = this->Vector.begin();
          i != this->Vector.end(); ++i) {
@@ -1655,7 +1655,7 @@ private:
     }
     return false;
   }
-  virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const
+  cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
   {
     cmsys::auto_ptr<cmFileListGeneratorBase> g(
       new cmFileListGeneratorEnumerate(*this));
@@ -1679,7 +1679,7 @@ public:
 
 private:
   std::vector<std::string> const& Names;
-  virtual bool Search(std::string const& parent, cmFileList& lister)
+  bool Search(std::string const& parent, cmFileList& lister) CM_OVERRIDE
   {
     // Construct a list of matches.
     std::vector<std::string> matches;
@@ -1706,7 +1706,7 @@ private:
     }
     return false;
   }
-  virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const
+  cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
   {
     cmsys::auto_ptr<cmFileListGeneratorBase> g(
       new cmFileListGeneratorProject(*this));
@@ -1734,7 +1734,7 @@ public:
 private:
   std::vector<std::string> const& Names;
   std::string Extension;
-  virtual bool Search(std::string const& parent, cmFileList& lister)
+  bool Search(std::string const& parent, cmFileList& lister) CM_OVERRIDE
   {
     // Construct a list of matches.
     std::vector<std::string> matches;
@@ -1763,7 +1763,7 @@ private:
     }
     return false;
   }
-  virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const
+  cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
   {
     cmsys::auto_ptr<cmFileListGeneratorBase> g(
       new cmFileListGeneratorMacProject(*this));
@@ -1788,7 +1788,7 @@ public:
 
 private:
   std::string String;
-  virtual bool Search(std::string const& parent, cmFileList& lister)
+  bool Search(std::string const& parent, cmFileList& lister) CM_OVERRIDE
   {
     // Look for matching files.
     std::vector<std::string> matches;
@@ -1807,7 +1807,7 @@ private:
     }
     return false;
   }
-  virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const
+  cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
   {
     cmsys::auto_ptr<cmFileListGeneratorBase> g(
       new cmFileListGeneratorCaseInsensitive(*this));
@@ -1831,7 +1831,7 @@ public:
 
 private:
   std::string Pattern;
-  virtual bool Search(std::string const& parent, cmFileList& lister)
+  bool Search(std::string const& parent, cmFileList& lister) CM_OVERRIDE
   {
     // Glob the set of matching files.
     std::string expr = parent;
@@ -1853,7 +1853,7 @@ private:
     }
     return false;
   }
-  virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const
+  cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
   {
     cmsys::auto_ptr<cmFileListGeneratorBase> g(
       new cmFileListGeneratorGlob(*this));
diff --git a/Source/cmFindPackageCommand.h b/Source/cmFindPackageCommand.h
index 2d14be2..087107e 100644
--- a/Source/cmFindPackageCommand.h
+++ b/Source/cmFindPackageCommand.h
@@ -29,24 +29,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmFindPackageCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmFindPackageCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "find_package"; }
+  std::string GetName() const CM_OVERRIDE { return "find_package"; }
 
   cmTypeMacro(cmFindPackageCommand, cmFindCommon);
 
diff --git a/Source/cmFindPathCommand.h b/Source/cmFindPathCommand.h
index e14626a..52ce3b0 100644
--- a/Source/cmFindPathCommand.h
+++ b/Source/cmFindPathCommand.h
@@ -28,24 +28,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmFindPathCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmFindPathCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "find_path"; }
+  std::string GetName() const CM_OVERRIDE { return "find_path"; }
 
   cmTypeMacro(cmFindPathCommand, cmFindBase);
   bool IncludeFileInPath;
diff --git a/Source/cmFindProgramCommand.h b/Source/cmFindProgramCommand.h
index 3f2ac0e..1953f59 100644
--- a/Source/cmFindProgramCommand.h
+++ b/Source/cmFindProgramCommand.h
@@ -29,24 +29,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmFindProgramCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmFindProgramCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "find_program"; }
+  std::string GetName() const CM_OVERRIDE { return "find_program"; }
 
   cmTypeMacro(cmFindProgramCommand, cmFindBase);
 
diff --git a/Source/cmForEachCommand.h b/Source/cmForEachCommand.h
index 60956aa..887e6e9 100644
--- a/Source/cmForEachCommand.h
+++ b/Source/cmForEachCommand.h
@@ -21,10 +21,10 @@ class cmForEachFunctionBlocker : public cmFunctionBlocker
 {
 public:
   cmForEachFunctionBlocker(cmMakefile* mf);
-  ~cmForEachFunctionBlocker();
-  virtual bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf,
-                                 cmExecutionStatus&);
-  virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf);
+  ~cmForEachFunctionBlocker() CM_OVERRIDE;
+  bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf,
+                         cmExecutionStatus&) CM_OVERRIDE;
+  bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf) CM_OVERRIDE;
 
   std::vector<std::string> Args;
   std::vector<cmListFileFunction> Functions;
@@ -41,24 +41,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmForEachCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmForEachCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "foreach"; }
+  std::string GetName() const CM_OVERRIDE { return "foreach"; }
 
   cmTypeMacro(cmForEachCommand, cmCommand);
 
diff --git a/Source/cmFunctionCommand.cxx b/Source/cmFunctionCommand.cxx
index de9887e..40c54db 100644
--- a/Source/cmFunctionCommand.cxx
+++ b/Source/cmFunctionCommand.cxx
@@ -20,7 +20,7 @@ public:
   cmFunctionHelperCommand() {}
 
   ///! clean up any memory allocated by the function
-  ~cmFunctionHelperCommand() {}
+  ~cmFunctionHelperCommand() CM_OVERRIDE {}
 
   /**
    * This is used to avoid including this command
@@ -28,12 +28,12 @@ public:
    * cmMacroHelperCommand and cmFunctionHelperCommand
    * which cannot provide appropriate documentation.
    */
-  virtual bool ShouldAppearInDocumentation() const { return false; }
+  bool ShouldAppearInDocumentation() const CM_OVERRIDE { return false; }
 
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmFunctionHelperCommand* newC = new cmFunctionHelperCommand;
     // we must copy when we clone
@@ -47,16 +47,17 @@ public:
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
-                                 cmExecutionStatus&);
+  bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
+                         cmExecutionStatus&) CM_OVERRIDE;
 
-  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  bool InitialPass(std::vector<std::string> const&,
+                   cmExecutionStatus&) CM_OVERRIDE
   {
     return false;
   }
@@ -64,7 +65,7 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return this->Args[0]; }
+  std::string GetName() const CM_OVERRIDE { return this->Args[0]; }
 
   cmTypeMacro(cmFunctionHelperCommand, cmCommand);
 
diff --git a/Source/cmFunctionCommand.h b/Source/cmFunctionCommand.h
index 08f7f0f..2c7a884 100644
--- a/Source/cmFunctionCommand.h
+++ b/Source/cmFunctionCommand.h
@@ -20,10 +20,10 @@ class cmFunctionFunctionBlocker : public cmFunctionBlocker
 {
 public:
   cmFunctionFunctionBlocker() { this->Depth = 0; }
-  virtual ~cmFunctionFunctionBlocker() {}
-  virtual bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile& mf,
-                                 cmExecutionStatus&);
-  virtual bool ShouldRemove(const cmListFileFunction&, cmMakefile& mf);
+  ~cmFunctionFunctionBlocker() CM_OVERRIDE {}
+  bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile& mf,
+                         cmExecutionStatus&) CM_OVERRIDE;
+  bool ShouldRemove(const cmListFileFunction&, cmMakefile& mf) CM_OVERRIDE;
 
   std::vector<std::string> Args;
   std::vector<cmListFileFunction> Functions;
@@ -37,24 +37,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmFunctionCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmFunctionCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "function"; }
+  std::string GetName() const CM_OVERRIDE { return "function"; }
 
   cmTypeMacro(cmFunctionCommand, cmCommand);
 };
diff --git a/Source/cmGeneratedFileStream.h b/Source/cmGeneratedFileStream.h
index a2de5bc..3480c5b 100644
--- a/Source/cmGeneratedFileStream.h
+++ b/Source/cmGeneratedFileStream.h
@@ -99,7 +99,7 @@ public:
    * file was successfully written before allowing the original to be
    * replaced.
    */
-  ~cmGeneratedFileStream();
+  ~cmGeneratedFileStream() CM_OVERRIDE;
 
   /**
    * Open an output file by name.  This should be used only with a
diff --git a/Source/cmGeneratorExpressionEvaluator.h b/Source/cmGeneratorExpressionEvaluator.h
index 7ca62c5..58e732b 100644
--- a/Source/cmGeneratorExpressionEvaluator.h
+++ b/Source/cmGeneratorExpressionEvaluator.h
@@ -52,12 +52,15 @@ struct TextContent : public cmGeneratorExpressionEvaluator
   }
 
   std::string Evaluate(cmGeneratorExpressionContext*,
-                       cmGeneratorExpressionDAGChecker*) const
+                       cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
   {
     return std::string(this->Content, this->Length);
   }
 
-  Type GetType() const { return cmGeneratorExpressionEvaluator::Text; }
+  Type GetType() const CM_OVERRIDE
+  {
+    return cmGeneratorExpressionEvaluator::Text;
+  }
 
   void Extend(size_t length) { this->Length += length; }
 
@@ -82,14 +85,17 @@ struct GeneratorExpressionContent : public cmGeneratorExpressionEvaluator
     this->ParamChildren = parameters;
   }
 
-  Type GetType() const { return cmGeneratorExpressionEvaluator::Generator; }
+  Type GetType() const CM_OVERRIDE
+  {
+    return cmGeneratorExpressionEvaluator::Generator;
+  }
 
   std::string Evaluate(cmGeneratorExpressionContext* context,
-                       cmGeneratorExpressionDAGChecker*) const;
+                       cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE;
 
   std::string GetOriginalExpression() const;
 
-  ~GeneratorExpressionContent();
+  ~GeneratorExpressionContent() CM_OVERRIDE;
 
 private:
   std::string EvaluateParameters(const cmGeneratorExpressionNode* node,
diff --git a/Source/cmGetCMakePropertyCommand.h b/Source/cmGetCMakePropertyCommand.h
index fd247e8..7df9cc1 100644
--- a/Source/cmGetCMakePropertyCommand.h
+++ b/Source/cmGetCMakePropertyCommand.h
@@ -17,24 +17,24 @@
 class cmGetCMakePropertyCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone() { return new cmGetCMakePropertyCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmGetCMakePropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "get_cmake_property"; }
+  std::string GetName() const CM_OVERRIDE { return "get_cmake_property"; }
 
   cmTypeMacro(cmGetCMakePropertyCommand, cmCommand);
 };
diff --git a/Source/cmGetDirectoryPropertyCommand.h b/Source/cmGetDirectoryPropertyCommand.h
index 97394ec..1be9aa4 100644
--- a/Source/cmGetDirectoryPropertyCommand.h
+++ b/Source/cmGetDirectoryPropertyCommand.h
@@ -17,24 +17,24 @@
 class cmGetDirectoryPropertyCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone() { return new cmGetDirectoryPropertyCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmGetDirectoryPropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "get_directory_property"; }
+  std::string GetName() const CM_OVERRIDE { return "get_directory_property"; }
 
   cmTypeMacro(cmGetDirectoryPropertyCommand, cmCommand);
 
diff --git a/Source/cmGetFilenameComponentCommand.h b/Source/cmGetFilenameComponentCommand.h
index a114b3d..d8609fe 100644
--- a/Source/cmGetFilenameComponentCommand.h
+++ b/Source/cmGetFilenameComponentCommand.h
@@ -26,24 +26,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmGetFilenameComponentCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmGetFilenameComponentCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "get_filename_component"; }
+  std::string GetName() const CM_OVERRIDE { return "get_filename_component"; }
 
   cmTypeMacro(cmGetFilenameComponentCommand, cmCommand);
 };
diff --git a/Source/cmGetPropertyCommand.h b/Source/cmGetPropertyCommand.h
index aeed01d..558226b 100644
--- a/Source/cmGetPropertyCommand.h
+++ b/Source/cmGetPropertyCommand.h
@@ -19,24 +19,24 @@ class cmGetPropertyCommand : public cmCommand
 public:
   cmGetPropertyCommand();
 
-  virtual cmCommand* Clone() { return new cmGetPropertyCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmGetPropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "get_property"; }
+  std::string GetName() const CM_OVERRIDE { return "get_property"; }
 
   cmTypeMacro(cmGetPropertyCommand, cmCommand);
 
diff --git a/Source/cmGetSourceFilePropertyCommand.h b/Source/cmGetSourceFilePropertyCommand.h
index 06f582f..2d2477c 100644
--- a/Source/cmGetSourceFilePropertyCommand.h
+++ b/Source/cmGetSourceFilePropertyCommand.h
@@ -17,19 +17,22 @@
 class cmGetSourceFilePropertyCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone() { return new cmGetSourceFilePropertyCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmGetSourceFilePropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "get_source_file_property"; }
+  std::string GetName() const CM_OVERRIDE
+  {
+    return "get_source_file_property";
+  }
 
   cmTypeMacro(cmGetSourceFilePropertyCommand, cmCommand);
 };
diff --git a/Source/cmGetTargetPropertyCommand.h b/Source/cmGetTargetPropertyCommand.h
index 9a1e18e..3e0fe36 100644
--- a/Source/cmGetTargetPropertyCommand.h
+++ b/Source/cmGetTargetPropertyCommand.h
@@ -17,19 +17,19 @@
 class cmGetTargetPropertyCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone() { return new cmGetTargetPropertyCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmGetTargetPropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "get_target_property"; }
+  std::string GetName() const CM_OVERRIDE { return "get_target_property"; }
 
   cmTypeMacro(cmGetTargetPropertyCommand, cmCommand);
 };
diff --git a/Source/cmGetTestPropertyCommand.h b/Source/cmGetTestPropertyCommand.h
index fc281c4..e419c98 100644
--- a/Source/cmGetTestPropertyCommand.h
+++ b/Source/cmGetTestPropertyCommand.h
@@ -17,19 +17,19 @@
 class cmGetTestPropertyCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone() { return new cmGetTestPropertyCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmGetTestPropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "get_test_property"; }
+  std::string GetName() const CM_OVERRIDE { return "get_test_property"; }
 
   cmTypeMacro(cmGetTestPropertyCommand, cmCommand);
 };
diff --git a/Source/cmGlobalCommonGenerator.h b/Source/cmGlobalCommonGenerator.h
index 7bb0e55..a48ff4f 100644
--- a/Source/cmGlobalCommonGenerator.h
+++ b/Source/cmGlobalCommonGenerator.h
@@ -21,7 +21,7 @@ class cmGlobalCommonGenerator : public cmGlobalGenerator
 {
 public:
   cmGlobalCommonGenerator(cmake* cm);
-  ~cmGlobalCommonGenerator();
+  ~cmGlobalCommonGenerator() CM_OVERRIDE;
 };
 
 #endif
diff --git a/Source/cmGlobalGeneratorFactory.h b/Source/cmGlobalGeneratorFactory.h
index 7d4fe2c..40678da 100644
--- a/Source/cmGlobalGeneratorFactory.h
+++ b/Source/cmGlobalGeneratorFactory.h
@@ -48,8 +48,8 @@ class cmGlobalGeneratorSimpleFactory : public cmGlobalGeneratorFactory
 {
 public:
   /** Create a GlobalGenerator */
-  virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
-                                                   cmake* cm) const
+  cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
+                                           cmake* cm) const CM_OVERRIDE
   {
     if (name != T::GetActualName()) {
       return 0;
@@ -58,19 +58,19 @@ public:
   }
 
   /** Get the documentation entry for this factory */
-  virtual void GetDocumentation(cmDocumentationEntry& entry) const
+  void GetDocumentation(cmDocumentationEntry& entry) const CM_OVERRIDE
   {
     T::GetDocumentation(entry);
   }
 
   /** Get the names of the current registered generators */
-  virtual void GetGenerators(std::vector<std::string>& names) const
+  void GetGenerators(std::vector<std::string>& names) const CM_OVERRIDE
   {
     names.push_back(T::GetActualName());
   }
 
   /** Determine whether or not this generator supports toolsets */
-  virtual bool SupportsToolset() const { return T::SupportsToolset(); }
+  bool SupportsToolset() const CM_OVERRIDE { return T::SupportsToolset(); }
 };
 
 #endif
diff --git a/Source/cmGlobalKdevelopGenerator.h b/Source/cmGlobalKdevelopGenerator.h
index 315e38e..c61cafb 100644
--- a/Source/cmGlobalKdevelopGenerator.h
+++ b/Source/cmGlobalKdevelopGenerator.h
@@ -33,7 +33,7 @@ class cmGlobalKdevelopGenerator : public cmExternalMakefileProjectGenerator
 public:
   cmGlobalKdevelopGenerator();
 
-  virtual std::string GetName() const
+  std::string GetName() const CM_OVERRIDE
   {
     return cmGlobalKdevelopGenerator::GetActualName();
   }
@@ -43,10 +43,10 @@ public:
     return new cmGlobalKdevelopGenerator;
   }
   /** Get the documentation entry for this generator.  */
-  virtual void GetDocumentation(cmDocumentationEntry& entry,
-                                const std::string& fullName) const;
+  void GetDocumentation(cmDocumentationEntry& entry,
+                        const std::string& fullName) const CM_OVERRIDE;
 
-  virtual void Generate();
+  void Generate() CM_OVERRIDE;
 
 private:
   /*** Create the foo.kdevelop.filelist file, return false if it doesn't
diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h
index 6d9bfe8..ea51fbf 100644
--- a/Source/cmGlobalNinjaGenerator.h
+++ b/Source/cmGlobalNinjaGenerator.h
@@ -161,11 +161,11 @@ public:
     return new cmGlobalGeneratorSimpleFactory<cmGlobalNinjaGenerator>();
   }
 
-  virtual ~cmGlobalNinjaGenerator() {}
+  ~cmGlobalNinjaGenerator() CM_OVERRIDE {}
 
-  virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf);
+  cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf) CM_OVERRIDE;
 
-  virtual std::string GetName() const
+  std::string GetName() const CM_OVERRIDE
   {
     return cmGlobalNinjaGenerator::GetActualName();
   }
@@ -174,39 +174,44 @@ public:
 
   static void GetDocumentation(cmDocumentationEntry& entry);
 
-  virtual void EnableLanguage(std::vector<std::string> const& languages,
-                              cmMakefile* mf, bool optional);
+  void EnableLanguage(std::vector<std::string> const& languages,
+                      cmMakefile* mf, bool optional) CM_OVERRIDE;
 
-  virtual void GenerateBuildCommand(
-    std::vector<std::string>& makeCommand, const std::string& makeProgram,
-    const std::string& projectName, const std::string& projectDir,
-    const std::string& targetName, const std::string& config, bool fast,
-    bool verbose,
-    std::vector<std::string> const& makeOptions = std::vector<std::string>());
+  void GenerateBuildCommand(std::vector<std::string>& makeCommand,
+                            const std::string& makeProgram,
+                            const std::string& projectName,
+                            const std::string& projectDir,
+                            const std::string& targetName,
+                            const std::string& config, bool fast, bool verbose,
+                            std::vector<std::string> const& makeOptions =
+                              std::vector<std::string>()) CM_OVERRIDE;
 
   // Setup target names
-  virtual const char* GetAllTargetName() const { return "all"; }
-  virtual const char* GetInstallTargetName() const { return "install"; }
-  virtual const char* GetInstallLocalTargetName() const
+  const char* GetAllTargetName() const CM_OVERRIDE { return "all"; }
+  const char* GetInstallTargetName() const CM_OVERRIDE { return "install"; }
+  const char* GetInstallLocalTargetName() const CM_OVERRIDE
   {
     return "install/local";
   }
-  virtual const char* GetInstallStripTargetName() const
+  const char* GetInstallStripTargetName() const CM_OVERRIDE
   {
     return "install/strip";
   }
-  virtual const char* GetTestTargetName() const { return "test"; }
-  virtual const char* GetPackageTargetName() const { return "package"; }
-  virtual const char* GetPackageSourceTargetName() const
+  const char* GetTestTargetName() const CM_OVERRIDE { return "test"; }
+  const char* GetPackageTargetName() const CM_OVERRIDE { return "package"; }
+  const char* GetPackageSourceTargetName() const CM_OVERRIDE
   {
     return "package_source";
   }
-  virtual const char* GetEditCacheTargetName() const { return "edit_cache"; }
-  virtual const char* GetRebuildCacheTargetName() const
+  const char* GetEditCacheTargetName() const CM_OVERRIDE
+  {
+    return "edit_cache";
+  }
+  const char* GetRebuildCacheTargetName() const CM_OVERRIDE
   {
     return "rebuild_cache";
   }
-  virtual const char* GetCleanTargetName() const { return "clean"; }
+  const char* GetCleanTargetName() const CM_OVERRIDE { return "clean"; }
 
   cmGeneratedFileStream* GetBuildFileStream() const
   {
@@ -307,7 +312,7 @@ public:
 
   void AddTargetAlias(const std::string& alias, cmGeneratorTarget* target);
 
-  virtual void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const;
+  void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const CM_OVERRIDE;
 
   // Ninja generator uses 'deps' and 'msvc_deps_prefix' introduced in 1.3
   static std::string RequiredNinjaVersion() { return "1.3"; }
@@ -319,13 +324,13 @@ public:
   void StripNinjaOutputPathPrefixAsSuffix(std::string& path);
 
 protected:
-  virtual void Generate();
+  void Generate() CM_OVERRIDE;
 
-  virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const { return true; }
+  bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const CM_OVERRIDE { return true; }
 
 private:
-  virtual std::string GetEditCacheCommand() const;
-  virtual void FindMakeProgram(cmMakefile* mf);
+  std::string GetEditCacheCommand() const CM_OVERRIDE;
+  void FindMakeProgram(cmMakefile* mf) CM_OVERRIDE;
 
   void OpenBuildFileStream();
   void CloseBuildFileStream();
diff --git a/Source/cmGlobalUnixMakefileGenerator3.h b/Source/cmGlobalUnixMakefileGenerator3.h
index f951b2a..98969ff 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.h
+++ b/Source/cmGlobalUnixMakefileGenerator3.h
@@ -63,7 +63,7 @@ public:
   }
 
   ///! Get the name for the generator.
-  virtual std::string GetName() const
+  std::string GetName() const CM_OVERRIDE
   {
     return cmGlobalUnixMakefileGenerator3::GetActualName();
   }
@@ -78,23 +78,23 @@ public:
   /** Get the documentation entry for this generator.  */
   static void GetDocumentation(cmDocumentationEntry& entry);
 
-  virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf);
+  cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf) CM_OVERRIDE;
 
   /**
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string> const& languages,
-                              cmMakefile*, bool optional);
+  void EnableLanguage(std::vector<std::string> const& languages, cmMakefile*,
+                      bool optional) CM_OVERRIDE;
 
-  virtual void Configure();
+  void Configure() CM_OVERRIDE;
 
   /**
    * Generate the all required files for building this project/tree. This
    * basically creates a series of LocalGenerators for each directory and
    * requests that they Generate.
    */
-  virtual void Generate();
+  void Generate() CM_OVERRIDE;
 
   void WriteMainCMakefileLanguageRules(cmGeneratedFileStream& cmakefileStream,
                                        std::vector<cmLocalGenerator*>&);
@@ -116,12 +116,14 @@ public:
   std::string GetEmptyRuleHackDepends() { return this->EmptyRuleHackDepends; }
 
   // change the build command for speed
-  virtual void GenerateBuildCommand(
-    std::vector<std::string>& makeCommand, const std::string& makeProgram,
-    const std::string& projectName, const std::string& projectDir,
-    const std::string& targetName, const std::string& config, bool fast,
-    bool verbose,
-    std::vector<std::string> const& makeOptions = std::vector<std::string>());
+  void GenerateBuildCommand(std::vector<std::string>& makeCommand,
+                            const std::string& makeProgram,
+                            const std::string& projectName,
+                            const std::string& projectDir,
+                            const std::string& targetName,
+                            const std::string& config, bool fast, bool verbose,
+                            std::vector<std::string> const& makeOptions =
+                              std::vector<std::string>()) CM_OVERRIDE;
 
   /** Record per-target progress information.  */
   void RecordTargetProgress(cmMakefileTargetGenerator* tg);
@@ -136,7 +138,7 @@ public:
   /** Does the make tool tolerate .DELETE_ON_ERROR? */
   virtual bool AllowDeleteOnError() const { return true; }
 
-  virtual void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const;
+  void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const CM_OVERRIDE;
 
   std::string IncludeDirective;
   bool DefineWindowsNULL;
@@ -163,19 +165,37 @@ protected:
   bool NeedRequiresStep(cmGeneratorTarget const*);
 
   // Target name hooks for superclass.
-  const char* GetAllTargetName() const { return "all"; }
-  const char* GetInstallTargetName() const { return "install"; }
-  const char* GetInstallLocalTargetName() const { return "install/local"; }
-  const char* GetInstallStripTargetName() const { return "install/strip"; }
-  const char* GetPreinstallTargetName() const { return "preinstall"; }
-  const char* GetTestTargetName() const { return "test"; }
-  const char* GetPackageTargetName() const { return "package"; }
-  const char* GetPackageSourceTargetName() const { return "package_source"; }
-  const char* GetEditCacheTargetName() const { return "edit_cache"; }
-  const char* GetRebuildCacheTargetName() const { return "rebuild_cache"; }
-  const char* GetCleanTargetName() const { return "clean"; }
-
-  virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const { return true; }
+  const char* GetAllTargetName() const CM_OVERRIDE { return "all"; }
+  const char* GetInstallTargetName() const CM_OVERRIDE { return "install"; }
+  const char* GetInstallLocalTargetName() const CM_OVERRIDE
+  {
+    return "install/local";
+  }
+  const char* GetInstallStripTargetName() const CM_OVERRIDE
+  {
+    return "install/strip";
+  }
+  const char* GetPreinstallTargetName() const CM_OVERRIDE
+  {
+    return "preinstall";
+  }
+  const char* GetTestTargetName() const CM_OVERRIDE { return "test"; }
+  const char* GetPackageTargetName() const CM_OVERRIDE { return "package"; }
+  const char* GetPackageSourceTargetName() const CM_OVERRIDE
+  {
+    return "package_source";
+  }
+  const char* GetEditCacheTargetName() const CM_OVERRIDE
+  {
+    return "edit_cache";
+  }
+  const char* GetRebuildCacheTargetName() const CM_OVERRIDE
+  {
+    return "rebuild_cache";
+  }
+  const char* GetCleanTargetName() const CM_OVERRIDE { return "clean"; }
+
+  bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const CM_OVERRIDE { return true; }
 
   // Some make programs (Borland) do not keep a rule if there are no
   // dependencies or commands.  This is a problem for creating rules
@@ -214,13 +234,13 @@ protected:
   cmGeneratedFileStream* CommandDatabase;
 
 private:
-  virtual const char* GetBuildIgnoreErrorsFlag() const { return "-i"; }
-  virtual std::string GetEditCacheCommand() const;
+  const char* GetBuildIgnoreErrorsFlag() const CM_OVERRIDE { return "-i"; }
+  std::string GetEditCacheCommand() const CM_OVERRIDE;
 
   std::map<cmState::Snapshot, std::set<cmGeneratorTarget const*>,
            cmState::Snapshot::StrictWeakOrder>
     DirectoryTargetsMap;
-  virtual void InitializeProgressMarks();
+  void InitializeProgressMarks() CM_OVERRIDE;
 };
 
 #endif
diff --git a/Source/cmGlobalWatcomWMakeGenerator.h b/Source/cmGlobalWatcomWMakeGenerator.h
index 3954907..bc0d786 100644
--- a/Source/cmGlobalWatcomWMakeGenerator.h
+++ b/Source/cmGlobalWatcomWMakeGenerator.h
@@ -28,7 +28,7 @@ public:
     return new cmGlobalGeneratorSimpleFactory<cmGlobalWatcomWMakeGenerator>();
   }
   ///! Get the name for the generator.
-  virtual std::string GetName() const
+  std::string GetName() const CM_OVERRIDE
   {
     return cmGlobalWatcomWMakeGenerator::GetActualName();
   }
@@ -41,11 +41,11 @@ public:
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string> const& languages,
-                              cmMakefile*, bool optional);
+  void EnableLanguage(std::vector<std::string> const& languages, cmMakefile*,
+                      bool optional) CM_OVERRIDE;
 
-  virtual bool AllowNotParallel() const { return false; }
-  virtual bool AllowDeleteOnError() const { return false; }
+  bool AllowNotParallel() const CM_OVERRIDE { return false; }
+  bool AllowDeleteOnError() const CM_OVERRIDE { return false; }
 };
 
 #endif
diff --git a/Source/cmIfCommand.h b/Source/cmIfCommand.h
index 54200df..f1f979d 100644
--- a/Source/cmIfCommand.h
+++ b/Source/cmIfCommand.h
@@ -24,10 +24,10 @@ public:
     this->HasRun = false;
     this->ScopeDepth = 0;
   }
-  virtual ~cmIfFunctionBlocker() {}
-  virtual bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf,
-                                 cmExecutionStatus&);
-  virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf);
+  ~cmIfFunctionBlocker() CM_OVERRIDE {}
+  bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf,
+                         cmExecutionStatus&) CM_OVERRIDE;
+  bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf) CM_OVERRIDE;
 
   std::vector<cmListFileArgument> Args;
   std::vector<cmListFileFunction> Functions;
@@ -43,20 +43,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmIfCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmIfCommand; }
 
   /**
    * This overrides the default InvokeInitialPass implementation.
    * It records the arguments before expansion.
    */
-  virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
-                                 cmExecutionStatus&);
+  bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
+                         cmExecutionStatus&) CM_OVERRIDE;
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  bool InitialPass(std::vector<std::string> const&,
+                   cmExecutionStatus&) CM_OVERRIDE
   {
     return false;
   }
@@ -64,12 +65,12 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "if"; }
+  std::string GetName() const CM_OVERRIDE { return "if"; }
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   // Filter the given variable definition based on policy CMP0054.
   static const char* GetDefinitionIfUnquoted(
diff --git a/Source/cmIncludeCommand.h b/Source/cmIncludeCommand.h
index e319dbd..365a830 100644
--- a/Source/cmIncludeCommand.h
+++ b/Source/cmIncludeCommand.h
@@ -26,24 +26,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmIncludeCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmIncludeCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "include"; }
+  std::string GetName() const CM_OVERRIDE { return "include"; }
 
   cmTypeMacro(cmIncludeCommand, cmCommand);
 };
diff --git a/Source/cmIncludeDirectoryCommand.h b/Source/cmIncludeDirectoryCommand.h
index 952294b..25be709 100644
--- a/Source/cmIncludeDirectoryCommand.h
+++ b/Source/cmIncludeDirectoryCommand.h
@@ -26,19 +26,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmIncludeDirectoryCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmIncludeDirectoryCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "include_directories"; }
+  std::string GetName() const CM_OVERRIDE { return "include_directories"; }
 
   cmTypeMacro(cmIncludeDirectoryCommand, cmCommand);
 
diff --git a/Source/cmIncludeExternalMSProjectCommand.h b/Source/cmIncludeExternalMSProjectCommand.h
index 999eb9e..8cda7b9 100644
--- a/Source/cmIncludeExternalMSProjectCommand.h
+++ b/Source/cmIncludeExternalMSProjectCommand.h
@@ -27,19 +27,25 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmIncludeExternalMSProjectCommand; }
+  cmCommand* Clone() CM_OVERRIDE
+  {
+    return new cmIncludeExternalMSProjectCommand;
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "include_external_msproject"; }
+  std::string GetName() const CM_OVERRIDE
+  {
+    return "include_external_msproject";
+  }
 
   cmTypeMacro(cmIncludeExternalMSProjectCommand, cmCommand);
 };
diff --git a/Source/cmIncludeRegularExpressionCommand.h b/Source/cmIncludeRegularExpressionCommand.h
index 1071a7a..52fdff0 100644
--- a/Source/cmIncludeRegularExpressionCommand.h
+++ b/Source/cmIncludeRegularExpressionCommand.h
@@ -26,19 +26,25 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmIncludeRegularExpressionCommand; }
+  cmCommand* Clone() CM_OVERRIDE
+  {
+    return new cmIncludeRegularExpressionCommand;
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "include_regular_expression"; }
+  std::string GetName() const CM_OVERRIDE
+  {
+    return "include_regular_expression";
+  }
 
   cmTypeMacro(cmIncludeRegularExpressionCommand, cmCommand);
 };
diff --git a/Source/cmInstallCommand.h b/Source/cmInstallCommand.h
index 93aca45..3718ad5 100644
--- a/Source/cmInstallCommand.h
+++ b/Source/cmInstallCommand.h
@@ -26,19 +26,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmInstallCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmInstallCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "install"; }
+  std::string GetName() const CM_OVERRIDE { return "install"; }
 
   cmTypeMacro(cmInstallCommand, cmCommand);
 
diff --git a/Source/cmInstallDirectoryGenerator.h b/Source/cmInstallDirectoryGenerator.h
index 10d7c95..93becf4 100644
--- a/Source/cmInstallDirectoryGenerator.h
+++ b/Source/cmInstallDirectoryGenerator.h
@@ -27,17 +27,17 @@ public:
                               const char* component, MessageLevel message,
                               bool exclude_from_all, const char* literal_args,
                               bool optional = false);
-  virtual ~cmInstallDirectoryGenerator();
+  ~cmInstallDirectoryGenerator() CM_OVERRIDE;
 
-  void Compute(cmLocalGenerator* lg);
+  void Compute(cmLocalGenerator* lg) CM_OVERRIDE;
 
   std::string GetDestination(std::string const& config) const;
 
 protected:
-  virtual void GenerateScriptActions(std::ostream& os, Indent const& indent);
-  virtual void GenerateScriptForConfig(std::ostream& os,
-                                       const std::string& config,
-                                       Indent const& indent);
+  void GenerateScriptActions(std::ostream& os,
+                             Indent const& indent) CM_OVERRIDE;
+  void GenerateScriptForConfig(std::ostream& os, const std::string& config,
+                               Indent const& indent) CM_OVERRIDE;
   void AddDirectoryInstallRule(std::ostream& os, const std::string& config,
                                Indent const& indent,
                                std::vector<std::string> const& dirs);
diff --git a/Source/cmInstallExportGenerator.h b/Source/cmInstallExportGenerator.h
index 256c0c9..4435f53 100644
--- a/Source/cmInstallExportGenerator.h
+++ b/Source/cmInstallExportGenerator.h
@@ -32,11 +32,11 @@ public:
                            const char* component, MessageLevel message,
                            bool exclude_from_all, const char* filename,
                            const char* name_space, bool exportOld);
-  ~cmInstallExportGenerator();
+  ~cmInstallExportGenerator() CM_OVERRIDE;
 
   cmExportSet* GetExportSet() { return this->ExportSet; }
 
-  void Compute(cmLocalGenerator* lg);
+  void Compute(cmLocalGenerator* lg) CM_OVERRIDE;
 
   cmLocalGenerator* GetLocalGenerator() const { return this->LocalGenerator; }
 
@@ -45,9 +45,11 @@ public:
   std::string const& GetDestination() const { return this->Destination; }
 
 protected:
-  virtual void GenerateScript(std::ostream& os);
-  virtual void GenerateScriptConfigs(std::ostream& os, Indent const& indent);
-  virtual void GenerateScriptActions(std::ostream& os, Indent const& indent);
+  void GenerateScript(std::ostream& os) CM_OVERRIDE;
+  void GenerateScriptConfigs(std::ostream& os,
+                             Indent const& indent) CM_OVERRIDE;
+  void GenerateScriptActions(std::ostream& os,
+                             Indent const& indent) CM_OVERRIDE;
   void GenerateImportFile(cmExportSet const* exportSet);
   void GenerateImportFile(const char* config, cmExportSet const* exportSet);
   void ComputeTempDir();
diff --git a/Source/cmInstallFilesCommand.h b/Source/cmInstallFilesCommand.h
index 0d0388a..cf2c9ff 100644
--- a/Source/cmInstallFilesCommand.h
+++ b/Source/cmInstallFilesCommand.h
@@ -26,19 +26,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmInstallFilesCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmInstallFilesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "install_files"; }
+  std::string GetName() const CM_OVERRIDE { return "install_files"; }
 
   /**
    * This is called at the end after all the information
@@ -46,8 +46,8 @@ public:
    * not implement this method.  At this point, reading and
    * writing to the cache can be done.
    */
-  virtual void FinalPass();
-  virtual bool HasFinalPass() const { return !this->IsFilesForm; }
+  void FinalPass() CM_OVERRIDE;
+  bool HasFinalPass() const CM_OVERRIDE { return !this->IsFilesForm; }
 
   cmTypeMacro(cmInstallFilesCommand, cmCommand);
 
diff --git a/Source/cmInstallFilesGenerator.h b/Source/cmInstallFilesGenerator.h
index 0e738d3..5cb09f4 100644
--- a/Source/cmInstallFilesGenerator.h
+++ b/Source/cmInstallFilesGenerator.h
@@ -27,17 +27,17 @@ public:
                           const char* component, MessageLevel message,
                           bool exclude_from_all, const char* rename,
                           bool optional = false);
-  virtual ~cmInstallFilesGenerator();
+  ~cmInstallFilesGenerator() CM_OVERRIDE;
 
-  void Compute(cmLocalGenerator* lg);
+  void Compute(cmLocalGenerator* lg) CM_OVERRIDE;
 
   std::string GetDestination(std::string const& config) const;
 
 protected:
-  virtual void GenerateScriptActions(std::ostream& os, Indent const& indent);
-  virtual void GenerateScriptForConfig(std::ostream& os,
-                                       const std::string& config,
-                                       Indent const& indent);
+  void GenerateScriptActions(std::ostream& os,
+                             Indent const& indent) CM_OVERRIDE;
+  void GenerateScriptForConfig(std::ostream& os, const std::string& config,
+                               Indent const& indent) CM_OVERRIDE;
   void AddFilesInstallRule(std::ostream& os, std::string const& config,
                            Indent const& indent,
                            std::vector<std::string> const& files);
diff --git a/Source/cmInstallGenerator.h b/Source/cmInstallGenerator.h
index e271d53..b003e78 100644
--- a/Source/cmInstallGenerator.h
+++ b/Source/cmInstallGenerator.h
@@ -37,7 +37,7 @@ public:
                      std::vector<std::string> const& configurations,
                      const char* component, MessageLevel message,
                      bool exclude_from_all);
-  virtual ~cmInstallGenerator();
+  ~cmInstallGenerator() CM_OVERRIDE;
 
   void AddInstallRule(std::ostream& os, std::string const& dest,
                       cmInstallType type,
@@ -60,7 +60,7 @@ public:
   virtual void Compute(cmLocalGenerator*) {}
 
 protected:
-  virtual void GenerateScript(std::ostream& os);
+  void GenerateScript(std::ostream& os) CM_OVERRIDE;
 
   std::string CreateComponentTest(const char* component,
                                   bool exclude_from_all);
diff --git a/Source/cmInstallProgramsCommand.h b/Source/cmInstallProgramsCommand.h
index b104c69..b56a9b1 100644
--- a/Source/cmInstallProgramsCommand.h
+++ b/Source/cmInstallProgramsCommand.h
@@ -26,19 +26,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmInstallProgramsCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmInstallProgramsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "install_programs"; }
+  std::string GetName() const CM_OVERRIDE { return "install_programs"; }
 
   /**
    * This is called at the end after all the information
@@ -46,9 +46,9 @@ public:
    * not implement this method.  At this point, reading and
    * writing to the cache can be done.
    */
-  virtual void FinalPass();
+  void FinalPass() CM_OVERRIDE;
 
-  virtual bool HasFinalPass() const { return true; }
+  bool HasFinalPass() const CM_OVERRIDE { return true; }
 
   cmTypeMacro(cmInstallProgramsCommand, cmCommand);
 
diff --git a/Source/cmInstallScriptGenerator.h b/Source/cmInstallScriptGenerator.h
index ff2f2fa..dc00359 100644
--- a/Source/cmInstallScriptGenerator.h
+++ b/Source/cmInstallScriptGenerator.h
@@ -22,10 +22,10 @@ class cmInstallScriptGenerator : public cmInstallGenerator
 public:
   cmInstallScriptGenerator(const char* script, bool code,
                            const char* component, bool exclude_from_all);
-  virtual ~cmInstallScriptGenerator();
+  ~cmInstallScriptGenerator() CM_OVERRIDE;
 
 protected:
-  virtual void GenerateScript(std::ostream& os);
+  void GenerateScript(std::ostream& os) CM_OVERRIDE;
   std::string Script;
   bool Code;
 };
diff --git a/Source/cmInstallTargetGenerator.h b/Source/cmInstallTargetGenerator.h
index 2fd85b5..b1c28b8 100644
--- a/Source/cmInstallTargetGenerator.h
+++ b/Source/cmInstallTargetGenerator.h
@@ -27,7 +27,7 @@ public:
                            std::vector<std::string> const& configurations,
                            const char* component, MessageLevel message,
                            bool exclude_from_all, bool optional);
-  virtual ~cmInstallTargetGenerator();
+  ~cmInstallTargetGenerator() CM_OVERRIDE;
 
   /** Select the policy for installing shared library linkable name
       symlinks.  */
@@ -54,7 +54,7 @@ public:
                                         const std::string& config,
                                         NameType nameType = NameNormal);
 
-  void Compute(cmLocalGenerator* lg);
+  void Compute(cmLocalGenerator* lg) CM_OVERRIDE;
 
   cmGeneratorTarget* GetTarget() const { return this->Target; }
 
@@ -63,10 +63,9 @@ public:
   std::string GetDestination(std::string const& config) const;
 
 protected:
-  virtual void GenerateScript(std::ostream& os);
-  virtual void GenerateScriptForConfig(std::ostream& os,
-                                       const std::string& config,
-                                       Indent const& indent);
+  void GenerateScript(std::ostream& os) CM_OVERRIDE;
+  void GenerateScriptForConfig(std::ostream& os, const std::string& config,
+                               Indent const& indent) CM_OVERRIDE;
   typedef void (cmInstallTargetGenerator::*TweakMethod)(std::ostream&,
                                                         Indent const&,
                                                         const std::string&,
diff --git a/Source/cmInstallTargetsCommand.h b/Source/cmInstallTargetsCommand.h
index b0d04b0..b7d7f33 100644
--- a/Source/cmInstallTargetsCommand.h
+++ b/Source/cmInstallTargetsCommand.h
@@ -27,19 +27,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmInstallTargetsCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmInstallTargetsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "install_targets"; }
+  std::string GetName() const CM_OVERRIDE { return "install_targets"; }
 
   cmTypeMacro(cmInstallTargetsCommand, cmCommand);
 };
diff --git a/Source/cmLinkDirectoriesCommand.h b/Source/cmLinkDirectoriesCommand.h
index 7014a69..721d663 100644
--- a/Source/cmLinkDirectoriesCommand.h
+++ b/Source/cmLinkDirectoriesCommand.h
@@ -28,19 +28,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmLinkDirectoriesCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmLinkDirectoriesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "link_directories"; }
+  std::string GetName() const CM_OVERRIDE { return "link_directories"; }
 
   cmTypeMacro(cmLinkDirectoriesCommand, cmCommand);
 
diff --git a/Source/cmLinkLibrariesCommand.h b/Source/cmLinkLibrariesCommand.h
index 6ab50ce..45cc4d7 100644
--- a/Source/cmLinkLibrariesCommand.h
+++ b/Source/cmLinkLibrariesCommand.h
@@ -27,19 +27,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmLinkLibrariesCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmLinkLibrariesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "link_libraries"; }
+  std::string GetName() const CM_OVERRIDE { return "link_libraries"; }
 
   cmTypeMacro(cmLinkLibrariesCommand, cmCommand);
 };
diff --git a/Source/cmListCommand.h b/Source/cmListCommand.h
index 56d9694..1c33c96 100644
--- a/Source/cmListCommand.h
+++ b/Source/cmListCommand.h
@@ -24,24 +24,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmListCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmListCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "list"; }
+  std::string GetName() const CM_OVERRIDE { return "list"; }
 
   cmTypeMacro(cmListCommand, cmCommand);
 
diff --git a/Source/cmLoadCacheCommand.h b/Source/cmLoadCacheCommand.h
index 67d93ac..0755809 100644
--- a/Source/cmLoadCacheCommand.h
+++ b/Source/cmLoadCacheCommand.h
@@ -25,19 +25,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmLoadCacheCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmLoadCacheCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "load_cache"; }
+  std::string GetName() const CM_OVERRIDE { return "load_cache"; }
 
   cmTypeMacro(cmLoadCacheCommand, cmCommand);
 
diff --git a/Source/cmLoadCommandCommand.cxx b/Source/cmLoadCommandCommand.cxx
index 081c22e..c2a5d46 100644
--- a/Source/cmLoadCommandCommand.cxx
+++ b/Source/cmLoadCommandCommand.cxx
@@ -37,12 +37,12 @@ public:
   }
 
   ///! clean up any memory allocated by the plugin
-  ~cmLoadedCommand();
+  ~cmLoadedCommand() CM_OVERRIDE;
 
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmLoadedCommand* newC = new cmLoadedCommand;
     // we must copy when we clone
@@ -54,8 +54,8 @@ public:
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus&);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus&) CM_OVERRIDE;
 
   /**
    * This is called at the end after all the information
@@ -63,8 +63,8 @@ public:
    * not implement this method.  At this point, reading and
    * writing to the cache can be done.
    */
-  virtual void FinalPass();
-  virtual bool HasFinalPass() const
+  void FinalPass() CM_OVERRIDE;
+  bool HasFinalPass() const CM_OVERRIDE
   {
     return this->info.FinalPass ? true : false;
   }
@@ -72,7 +72,7 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return info.Name; }
+  std::string GetName() const CM_OVERRIDE { return info.Name; }
 
   static const char* LastName;
   static void TrapsForSignals(int sig)
diff --git a/Source/cmLoadCommandCommand.h b/Source/cmLoadCommandCommand.h
index e00a01e..6552845 100644
--- a/Source/cmLoadCommandCommand.h
+++ b/Source/cmLoadCommandCommand.h
@@ -17,10 +17,10 @@
 class cmLoadCommandCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone() { return new cmLoadCommandCommand; }
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
-  virtual std::string GetName() const { return "load_command"; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmLoadCommandCommand; }
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
+  std::string GetName() const CM_OVERRIDE { return "load_command"; }
   cmTypeMacro(cmLoadCommandCommand, cmCommand);
 };
 
diff --git a/Source/cmLocalCommonGenerator.h b/Source/cmLocalCommonGenerator.h
index fd17ae3..0a8753d 100644
--- a/Source/cmLocalCommonGenerator.h
+++ b/Source/cmLocalCommonGenerator.h
@@ -24,7 +24,7 @@ class cmLocalCommonGenerator : public cmLocalGenerator
 public:
   cmLocalCommonGenerator(cmGlobalGenerator* gg, cmMakefile* mf,
                          cmOutputConverter::RelativeRoot wd);
-  ~cmLocalCommonGenerator();
+  ~cmLocalCommonGenerator() CM_OVERRIDE;
 
   std::string const& GetConfigName() { return this->ConfigName; }
 
@@ -34,7 +34,7 @@ public:
   }
 
   std::string GetTargetFortranFlags(cmGeneratorTarget const* target,
-                                    std::string const& config);
+                                    std::string const& config) CM_OVERRIDE;
 
 protected:
   cmOutputConverter::RelativeRoot WorkingDirectory;
diff --git a/Source/cmLocalNinjaGenerator.h b/Source/cmLocalNinjaGenerator.h
index 9899360..75da328 100644
--- a/Source/cmLocalNinjaGenerator.h
+++ b/Source/cmLocalNinjaGenerator.h
@@ -34,12 +34,12 @@ class cmLocalNinjaGenerator : public cmLocalCommonGenerator
 public:
   cmLocalNinjaGenerator(cmGlobalGenerator* gg, cmMakefile* mf);
 
-  virtual ~cmLocalNinjaGenerator();
+  ~cmLocalNinjaGenerator() CM_OVERRIDE;
 
-  virtual void Generate();
+  void Generate() CM_OVERRIDE;
 
-  virtual std::string GetTargetDirectory(
-    cmGeneratorTarget const* target) const;
+  std::string GetTargetDirectory(cmGeneratorTarget const* target) const
+    CM_OVERRIDE;
 
   const cmGlobalNinjaGenerator* GetGlobalNinjaGenerator() const;
   cmGlobalNinjaGenerator* GetGlobalNinjaGenerator();
@@ -72,19 +72,19 @@ public:
   void AppendCustomCommandDeps(cmCustomCommandGenerator const& ccg,
                                cmNinjaDeps& ninjaDeps);
 
-  virtual std::string ConvertToLinkReference(
-    std::string const& lib,
-    cmOutputConverter::OutputFormat format = cmOutputConverter::SHELL);
+  std::string ConvertToLinkReference(std::string const& lib,
+                                     cmOutputConverter::OutputFormat format =
+                                       cmOutputConverter::SHELL) CM_OVERRIDE;
 
-  virtual void ComputeObjectFilenames(
+  void ComputeObjectFilenames(
     std::map<cmSourceFile const*, std::string>& mapping,
-    cmGeneratorTarget const* gt = 0);
+    cmGeneratorTarget const* gt = 0) CM_OVERRIDE;
 
 protected:
-  virtual std::string ConvertToIncludeReference(
+  std::string ConvertToIncludeReference(
     std::string const& path,
     cmOutputConverter::OutputFormat format = cmOutputConverter::SHELL,
-    bool forceFullPaths = false);
+    bool forceFullPaths = false) CM_OVERRIDE;
 
 private:
   cmGeneratedFileStream& GetBuildFileStream() const;
diff --git a/Source/cmLocalUnixMakefileGenerator3.h b/Source/cmLocalUnixMakefileGenerator3.h
index a65a1a1..319a587 100644
--- a/Source/cmLocalUnixMakefileGenerator3.h
+++ b/Source/cmLocalUnixMakefileGenerator3.h
@@ -33,14 +33,14 @@ class cmLocalUnixMakefileGenerator3 : public cmLocalCommonGenerator
 {
 public:
   cmLocalUnixMakefileGenerator3(cmGlobalGenerator* gg, cmMakefile* mf);
-  virtual ~cmLocalUnixMakefileGenerator3();
+  ~cmLocalUnixMakefileGenerator3() CM_OVERRIDE;
 
-  virtual void ComputeHomeRelativeOutputPath();
+  void ComputeHomeRelativeOutputPath() CM_OVERRIDE;
 
   /**
    * Generate the makefile for this directory.
    */
-  virtual void Generate();
+  void Generate() CM_OVERRIDE;
 
   // this returns the relative path between the HomeOutputDirectory and this
   // local generators StartOutputDirectory
@@ -90,8 +90,9 @@ public:
                                    const std::string& tgt);
 
   // append flags to a string
-  virtual void AppendFlags(std::string& flags, const std::string& newFlags);
-  virtual void AppendFlags(std::string& flags, const char* newFlags);
+  void AppendFlags(std::string& flags,
+                   const std::string& newFlags) CM_OVERRIDE;
+  void AppendFlags(std::string& flags, const char* newFlags) CM_OVERRIDE;
 
   // append an echo command
   enum EchoColor
@@ -114,8 +115,8 @@ public:
   /** Get whether the makefile is to have color.  */
   bool GetColorMakefile() const { return this->ColorMakefile; }
 
-  virtual std::string GetTargetDirectory(
-    cmGeneratorTarget const* target) const;
+  std::string GetTargetDirectory(cmGeneratorTarget const* target) const
+    CM_OVERRIDE;
 
   // create a command that cds to the start dir then runs the commands
   void CreateCDCommand(std::vector<std::string>& commands,
@@ -130,11 +131,11 @@ public:
 
   /** Called from command-line hook to bring dependencies up to date
       for a target.  */
-  virtual bool UpdateDependencies(const char* tgtInfo, bool verbose,
-                                  bool color);
+  bool UpdateDependencies(const char* tgtInfo, bool verbose,
+                          bool color) CM_OVERRIDE;
 
   /** Called from command-line hook to clear dependencies.  */
-  virtual void ClearDependencies(cmMakefile* mf, bool verbose);
+  void ClearDependencies(cmMakefile* mf, bool verbose) CM_OVERRIDE;
 
   /** write some extra rules such as make test etc */
   void WriteSpecialTargetsTop(std::ostream& makefileStream);
@@ -253,9 +254,9 @@ private:
                            cmGeneratorTarget* target,
                            cmOutputConverter::RelativeRoot relative);
 
-  virtual void ComputeObjectFilenames(
+  void ComputeObjectFilenames(
     std::map<cmSourceFile const*, std::string>& mapping,
-    cmGeneratorTarget const* gt = 0);
+    cmGeneratorTarget const* gt = 0) CM_OVERRIDE;
 
   friend class cmMakefileTargetGenerator;
   friend class cmMakefileExecutableTargetGenerator;
diff --git a/Source/cmMacroCommand.cxx b/Source/cmMacroCommand.cxx
index 2caa401..ee9dc8a 100644
--- a/Source/cmMacroCommand.cxx
+++ b/Source/cmMacroCommand.cxx
@@ -21,7 +21,7 @@ public:
   cmMacroHelperCommand() {}
 
   ///! clean up any memory allocated by the macro
-  ~cmMacroHelperCommand() {}
+  ~cmMacroHelperCommand() CM_OVERRIDE {}
 
   /**
    * This is used to avoid including this command
@@ -29,12 +29,12 @@ public:
    * cmMacroHelperCommand and cmFunctionHelperCommand
    * which cannot provide appropriate documentation.
    */
-  virtual bool ShouldAppearInDocumentation() const { return false; }
+  bool ShouldAppearInDocumentation() const CM_OVERRIDE { return false; }
 
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
+  cmCommand* Clone() CM_OVERRIDE
   {
     cmMacroHelperCommand* newC = new cmMacroHelperCommand;
     // we must copy when we clone
@@ -48,16 +48,17 @@ public:
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
-                                 cmExecutionStatus&);
+  bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
+                         cmExecutionStatus&) CM_OVERRIDE;
 
-  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  bool InitialPass(std::vector<std::string> const&,
+                   cmExecutionStatus&) CM_OVERRIDE
   {
     return false;
   }
@@ -65,7 +66,7 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return this->Args[0]; }
+  std::string GetName() const CM_OVERRIDE { return this->Args[0]; }
 
   cmTypeMacro(cmMacroHelperCommand, cmCommand);
 
diff --git a/Source/cmMacroCommand.h b/Source/cmMacroCommand.h
index 11d2e1c..541b54f 100644
--- a/Source/cmMacroCommand.h
+++ b/Source/cmMacroCommand.h
@@ -20,10 +20,10 @@ class cmMacroFunctionBlocker : public cmFunctionBlocker
 {
 public:
   cmMacroFunctionBlocker() { this->Depth = 0; }
-  virtual ~cmMacroFunctionBlocker() {}
-  virtual bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile& mf,
-                                 cmExecutionStatus&);
-  virtual bool ShouldRemove(const cmListFileFunction&, cmMakefile& mf);
+  ~cmMacroFunctionBlocker() CM_OVERRIDE {}
+  bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile& mf,
+                         cmExecutionStatus&) CM_OVERRIDE;
+  bool ShouldRemove(const cmListFileFunction&, cmMakefile& mf) CM_OVERRIDE;
 
   std::vector<std::string> Args;
   std::vector<cmListFileFunction> Functions;
@@ -37,24 +37,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmMacroCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmMacroCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "macro"; }
+  std::string GetName() const CM_OVERRIDE { return "macro"; }
 
   cmTypeMacro(cmMacroCommand, cmCommand);
 };
diff --git a/Source/cmMakeDirectoryCommand.h b/Source/cmMakeDirectoryCommand.h
index 1a86398..de4ab8b 100644
--- a/Source/cmMakeDirectoryCommand.h
+++ b/Source/cmMakeDirectoryCommand.h
@@ -29,24 +29,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmMakeDirectoryCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmMakeDirectoryCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "make_directory"; }
+  std::string GetName() const CM_OVERRIDE { return "make_directory"; }
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   cmTypeMacro(cmMakeDirectoryCommand, cmCommand);
 };
diff --git a/Source/cmMakefileExecutableTargetGenerator.h b/Source/cmMakefileExecutableTargetGenerator.h
index 64cb17f..39def27 100644
--- a/Source/cmMakefileExecutableTargetGenerator.h
+++ b/Source/cmMakefileExecutableTargetGenerator.h
@@ -18,11 +18,11 @@ class cmMakefileExecutableTargetGenerator : public cmMakefileTargetGenerator
 {
 public:
   cmMakefileExecutableTargetGenerator(cmGeneratorTarget* target);
-  virtual ~cmMakefileExecutableTargetGenerator();
+  ~cmMakefileExecutableTargetGenerator() CM_OVERRIDE;
 
   /* the main entry point for this class. Writes the Makefiles associated
      with this target */
-  virtual void WriteRuleFiles();
+  void WriteRuleFiles() CM_OVERRIDE;
 
 protected:
   virtual void WriteExecutableRule(bool relink);
diff --git a/Source/cmMakefileLibraryTargetGenerator.h b/Source/cmMakefileLibraryTargetGenerator.h
index f72dbd7..935d8b1 100644
--- a/Source/cmMakefileLibraryTargetGenerator.h
+++ b/Source/cmMakefileLibraryTargetGenerator.h
@@ -18,11 +18,11 @@ class cmMakefileLibraryTargetGenerator : public cmMakefileTargetGenerator
 {
 public:
   cmMakefileLibraryTargetGenerator(cmGeneratorTarget* target);
-  virtual ~cmMakefileLibraryTargetGenerator();
+  ~cmMakefileLibraryTargetGenerator() CM_OVERRIDE;
 
   /* the main entry point for this class. Writes the Makefiles associated
      with this target */
-  virtual void WriteRuleFiles();
+  void WriteRuleFiles() CM_OVERRIDE;
 
 protected:
   void WriteObjectLibraryRules();
diff --git a/Source/cmMakefileTargetGenerator.h b/Source/cmMakefileTargetGenerator.h
index c513026..7749d8b 100644
--- a/Source/cmMakefileTargetGenerator.h
+++ b/Source/cmMakefileTargetGenerator.h
@@ -35,7 +35,7 @@ class cmMakefileTargetGenerator : public cmCommonTargetGenerator
 public:
   // constructor to set the ivars
   cmMakefileTargetGenerator(cmGeneratorTarget* target);
-  virtual ~cmMakefileTargetGenerator();
+  ~cmMakefileTargetGenerator() CM_OVERRIDE;
 
   // construct using this factory call
   static cmMakefileTargetGenerator* New(cmGeneratorTarget* tgt);
@@ -83,7 +83,8 @@ protected:
     {
     }
 
-    void operator()(cmSourceFile const& source, const char* pkgloc);
+    void operator()(cmSourceFile const& source,
+                    const char* pkgloc) CM_OVERRIDE;
 
   private:
     cmMakefileTargetGenerator* Generator;
@@ -161,7 +162,8 @@ protected:
                          std::vector<std::string>& makefile_depends,
                          bool useWatcomQuote);
 
-  void AddIncludeFlags(std::string& flags, const std::string& lang);
+  void AddIncludeFlags(std::string& flags,
+                       const std::string& lang) CM_OVERRIDE;
 
   virtual void CloseFileStreams();
   void RemoveForbiddenFlags(const char* flagVar, const std::string& linkLang,
diff --git a/Source/cmMakefileUtilityTargetGenerator.h b/Source/cmMakefileUtilityTargetGenerator.h
index dbb312c..b41fb8b 100644
--- a/Source/cmMakefileUtilityTargetGenerator.h
+++ b/Source/cmMakefileUtilityTargetGenerator.h
@@ -18,11 +18,11 @@ class cmMakefileUtilityTargetGenerator : public cmMakefileTargetGenerator
 {
 public:
   cmMakefileUtilityTargetGenerator(cmGeneratorTarget* target);
-  virtual ~cmMakefileUtilityTargetGenerator();
+  ~cmMakefileUtilityTargetGenerator() CM_OVERRIDE;
 
   /* the main entry point for this class. Writes the Makefiles associated
      with this target */
-  virtual void WriteRuleFiles();
+  void WriteRuleFiles() CM_OVERRIDE;
 
 protected:
 };
diff --git a/Source/cmMarkAsAdvancedCommand.h b/Source/cmMarkAsAdvancedCommand.h
index add43c9..bb1b83c 100644
--- a/Source/cmMarkAsAdvancedCommand.h
+++ b/Source/cmMarkAsAdvancedCommand.h
@@ -25,19 +25,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmMarkAsAdvancedCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmMarkAsAdvancedCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "mark_as_advanced"; }
+  std::string GetName() const CM_OVERRIDE { return "mark_as_advanced"; }
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -45,7 +45,7 @@ public:
    * make many of the modules usable in cmake/ctest scripts, (among them
    * FindUnixMake.cmake used by the CTEST_BUILD command.
   */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   cmTypeMacro(cmMarkAsAdvancedCommand, cmCommand);
 };
diff --git a/Source/cmMathCommand.h b/Source/cmMathCommand.h
index 3ac6f41..b99e790 100644
--- a/Source/cmMathCommand.h
+++ b/Source/cmMathCommand.h
@@ -21,24 +21,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmMathCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmMathCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "math"; }
+  std::string GetName() const CM_OVERRIDE { return "math"; }
 
   cmTypeMacro(cmMathCommand, cmCommand);
 
diff --git a/Source/cmMessageCommand.h b/Source/cmMessageCommand.h
index afc5509..61767a1 100644
--- a/Source/cmMessageCommand.h
+++ b/Source/cmMessageCommand.h
@@ -24,24 +24,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmMessageCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmMessageCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "message"; }
+  std::string GetName() const CM_OVERRIDE { return "message"; }
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   cmTypeMacro(cmMessageCommand, cmCommand);
 };
diff --git a/Source/cmNinjaNormalTargetGenerator.h b/Source/cmNinjaNormalTargetGenerator.h
index 300618c..f466e17 100644
--- a/Source/cmNinjaNormalTargetGenerator.h
+++ b/Source/cmNinjaNormalTargetGenerator.h
@@ -27,9 +27,9 @@ class cmNinjaNormalTargetGenerator : public cmNinjaTargetGenerator
 {
 public:
   cmNinjaNormalTargetGenerator(cmGeneratorTarget* target);
-  ~cmNinjaNormalTargetGenerator();
+  ~cmNinjaNormalTargetGenerator() CM_OVERRIDE;
 
-  void Generate();
+  void Generate() CM_OVERRIDE;
 
 private:
   std::string LanguageLinkerRule() const;
diff --git a/Source/cmNinjaTargetGenerator.h b/Source/cmNinjaTargetGenerator.h
index 44346c1..9740f0e 100644
--- a/Source/cmNinjaTargetGenerator.h
+++ b/Source/cmNinjaTargetGenerator.h
@@ -37,7 +37,7 @@ public:
   cmNinjaTargetGenerator(cmGeneratorTarget* target);
 
   /// Destructor.
-  virtual ~cmNinjaTargetGenerator();
+  ~cmNinjaTargetGenerator() CM_OVERRIDE;
 
   virtual void Generate() = 0;
 
@@ -79,7 +79,8 @@ protected:
   std::string ComputeFlagsForObject(cmSourceFile const* source,
                                     const std::string& language);
 
-  void AddIncludeFlags(std::string& flags, std::string const& lang);
+  void AddIncludeFlags(std::string& flags,
+                       std::string const& lang) CM_OVERRIDE;
 
   std::string ComputeDefines(cmSourceFile const* source,
                              const std::string& language);
@@ -134,7 +135,8 @@ protected:
     {
     }
 
-    void operator()(cmSourceFile const& source, const char* pkgloc);
+    void operator()(cmSourceFile const& source,
+                    const char* pkgloc) CM_OVERRIDE;
 
   private:
     cmNinjaTargetGenerator* Generator;
diff --git a/Source/cmNinjaUtilityTargetGenerator.h b/Source/cmNinjaUtilityTargetGenerator.h
index fec2946..0c33a54 100644
--- a/Source/cmNinjaUtilityTargetGenerator.h
+++ b/Source/cmNinjaUtilityTargetGenerator.h
@@ -23,9 +23,9 @@ class cmNinjaUtilityTargetGenerator : public cmNinjaTargetGenerator
 {
 public:
   cmNinjaUtilityTargetGenerator(cmGeneratorTarget* target);
-  ~cmNinjaUtilityTargetGenerator();
+  ~cmNinjaUtilityTargetGenerator() CM_OVERRIDE;
 
-  void Generate();
+  void Generate() CM_OVERRIDE;
 };
 
 #endif // ! cmNinjaUtilityTargetGenerator_h
diff --git a/Source/cmOptionCommand.h b/Source/cmOptionCommand.h
index 491f45e..6e6b076 100644
--- a/Source/cmOptionCommand.h
+++ b/Source/cmOptionCommand.h
@@ -25,24 +25,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmOptionCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmOptionCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "option"; }
+  std::string GetName() const CM_OVERRIDE { return "option"; }
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   cmTypeMacro(cmOptionCommand, cmCommand);
 };
diff --git a/Source/cmOutputRequiredFilesCommand.h b/Source/cmOutputRequiredFilesCommand.h
index 7a6f5a6..8838d09 100644
--- a/Source/cmOutputRequiredFilesCommand.h
+++ b/Source/cmOutputRequiredFilesCommand.h
@@ -20,10 +20,10 @@ class cmOutputRequiredFilesCommand : public cmCommand
 {
 public:
   cmTypeMacro(cmOutputRequiredFilesCommand, cmCommand);
-  virtual cmCommand* Clone() { return new cmOutputRequiredFilesCommand; }
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
-  virtual std::string GetName() const { return "output_required_files"; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmOutputRequiredFilesCommand; }
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
+  std::string GetName() const CM_OVERRIDE { return "output_required_files"; }
 
   void ListDependencies(cmDependInformation const* info, FILE* fout,
                         std::set<cmDependInformation const*>* visited);
diff --git a/Source/cmParseArgumentsCommand.h b/Source/cmParseArgumentsCommand.h
index 46d9daa..fcd9992 100644
--- a/Source/cmParseArgumentsCommand.h
+++ b/Source/cmParseArgumentsCommand.h
@@ -24,24 +24,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmParseArgumentsCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmParseArgumentsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "cmake_parse_arguments"; }
+  std::string GetName() const CM_OVERRIDE { return "cmake_parse_arguments"; }
 
   cmTypeMacro(cmParseArgumentsCommand, cmCommand);
 };
diff --git a/Source/cmProcessTools.h b/Source/cmProcessTools.h
index a48e52b..9d082b2 100644
--- a/Source/cmProcessTools.h
+++ b/Source/cmProcessTools.h
@@ -62,7 +62,7 @@ public:
     char Separator;
     char LineEnd;
     bool IgnoreCR;
-    virtual bool ProcessChunk(const char* data, int length);
+    bool ProcessChunk(const char* data, int length) CM_OVERRIDE;
 
     /** Implement in a subclass to process one line of input.  It
         should return true only if it is interested in more data.  */
@@ -79,7 +79,7 @@ public:
     }
 
   private:
-    virtual bool ProcessLine() { return true; }
+    bool ProcessLine() CM_OVERRIDE { return true; }
   };
 
   /** Run a process and send output to given parsers.  */
diff --git a/Source/cmProjectCommand.h b/Source/cmProjectCommand.h
index a4e6367..3318df1 100644
--- a/Source/cmProjectCommand.h
+++ b/Source/cmProjectCommand.h
@@ -28,19 +28,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmProjectCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmProjectCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "project"; }
+  std::string GetName() const CM_OVERRIDE { return "project"; }
 
   cmTypeMacro(cmProjectCommand, cmCommand);
 };
diff --git a/Source/cmQTWrapCPPCommand.h b/Source/cmQTWrapCPPCommand.h
index 2014828..78d5510 100644
--- a/Source/cmQTWrapCPPCommand.h
+++ b/Source/cmQTWrapCPPCommand.h
@@ -30,19 +30,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmQTWrapCPPCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmQTWrapCPPCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "qt_wrap_cpp"; }
+  std::string GetName() const CM_OVERRIDE { return "qt_wrap_cpp"; }
 };
 
 #endif
diff --git a/Source/cmQTWrapUICommand.h b/Source/cmQTWrapUICommand.h
index 48cfc77..a34a7bf 100644
--- a/Source/cmQTWrapUICommand.h
+++ b/Source/cmQTWrapUICommand.h
@@ -28,19 +28,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmQTWrapUICommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmQTWrapUICommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "qt_wrap_ui"; }
+  std::string GetName() const CM_OVERRIDE { return "qt_wrap_ui"; }
 };
 
 #endif
diff --git a/Source/cmRemoveCommand.h b/Source/cmRemoveCommand.h
index c226a54..1deff36 100644
--- a/Source/cmRemoveCommand.h
+++ b/Source/cmRemoveCommand.h
@@ -25,24 +25,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmRemoveCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmRemoveCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "remove"; }
+  std::string GetName() const CM_OVERRIDE { return "remove"; }
 
   cmTypeMacro(cmRemoveCommand, cmCommand);
 };
diff --git a/Source/cmRemoveDefinitionsCommand.h b/Source/cmRemoveDefinitionsCommand.h
index b440307..7fb2e5f 100644
--- a/Source/cmRemoveDefinitionsCommand.h
+++ b/Source/cmRemoveDefinitionsCommand.h
@@ -27,19 +27,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmRemoveDefinitionsCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmRemoveDefinitionsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "remove_definitions"; }
+  std::string GetName() const CM_OVERRIDE { return "remove_definitions"; }
 
   cmTypeMacro(cmRemoveDefinitionsCommand, cmCommand);
 };
diff --git a/Source/cmReturnCommand.h b/Source/cmReturnCommand.h
index 44cd4c8..ddf3613 100644
--- a/Source/cmReturnCommand.h
+++ b/Source/cmReturnCommand.h
@@ -25,24 +25,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmReturnCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmReturnCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "return"; }
+  std::string GetName() const CM_OVERRIDE { return "return"; }
 
   cmTypeMacro(cmReturnCommand, cmCommand);
 };
diff --git a/Source/cmSeparateArgumentsCommand.h b/Source/cmSeparateArgumentsCommand.h
index 47246c9..3c9e7d7 100644
--- a/Source/cmSeparateArgumentsCommand.h
+++ b/Source/cmSeparateArgumentsCommand.h
@@ -25,24 +25,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmSeparateArgumentsCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmSeparateArgumentsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "separate_arguments"; }
+  std::string GetName() const CM_OVERRIDE { return "separate_arguments"; }
 
   cmTypeMacro(cmSeparateArgumentsCommand, cmCommand);
 };
diff --git a/Source/cmSetCommand.h b/Source/cmSetCommand.h
index 65af8ac..b51eed0 100644
--- a/Source/cmSetCommand.h
+++ b/Source/cmSetCommand.h
@@ -25,24 +25,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmSetCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmSetCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "set"; }
+  std::string GetName() const CM_OVERRIDE { return "set"; }
 
   cmTypeMacro(cmSetCommand, cmCommand);
 };
diff --git a/Source/cmSetDirectoryPropertiesCommand.h b/Source/cmSetDirectoryPropertiesCommand.h
index a393eee..ef476ec 100644
--- a/Source/cmSetDirectoryPropertiesCommand.h
+++ b/Source/cmSetDirectoryPropertiesCommand.h
@@ -17,24 +17,30 @@
 class cmSetDirectoryPropertiesCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone() { return new cmSetDirectoryPropertiesCommand; }
+  cmCommand* Clone() CM_OVERRIDE
+  {
+    return new cmSetDirectoryPropertiesCommand;
+  }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "set_directory_properties"; }
+  std::string GetName() const CM_OVERRIDE
+  {
+    return "set_directory_properties";
+  }
 
   /**
    * Static entry point for use by other commands
diff --git a/Source/cmSetPropertyCommand.h b/Source/cmSetPropertyCommand.h
index a85d652..e78b04c 100644
--- a/Source/cmSetPropertyCommand.h
+++ b/Source/cmSetPropertyCommand.h
@@ -19,24 +19,24 @@ class cmSetPropertyCommand : public cmCommand
 public:
   cmSetPropertyCommand();
 
-  virtual cmCommand* Clone() { return new cmSetPropertyCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmSetPropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "set_property"; }
+  std::string GetName() const CM_OVERRIDE { return "set_property"; }
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   cmTypeMacro(cmSetPropertyCommand, cmCommand);
 
diff --git a/Source/cmSetSourceFilesPropertiesCommand.h b/Source/cmSetSourceFilesPropertiesCommand.h
index 20e6b93..f6b4de0 100644
--- a/Source/cmSetSourceFilesPropertiesCommand.h
+++ b/Source/cmSetSourceFilesPropertiesCommand.h
@@ -17,19 +17,25 @@
 class cmSetSourceFilesPropertiesCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone() { return new cmSetSourceFilesPropertiesCommand; }
+  cmCommand* Clone() CM_OVERRIDE
+  {
+    return new cmSetSourceFilesPropertiesCommand;
+  }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "set_source_files_properties"; }
+  std::string GetName() const CM_OVERRIDE
+  {
+    return "set_source_files_properties";
+  }
 
   cmTypeMacro(cmSetSourceFilesPropertiesCommand, cmCommand);
 
diff --git a/Source/cmSetTargetPropertiesCommand.h b/Source/cmSetTargetPropertiesCommand.h
index 122c15e..1ed8d90 100644
--- a/Source/cmSetTargetPropertiesCommand.h
+++ b/Source/cmSetTargetPropertiesCommand.h
@@ -17,19 +17,19 @@
 class cmSetTargetPropertiesCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone() { return new cmSetTargetPropertiesCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmSetTargetPropertiesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "set_target_properties"; }
+  std::string GetName() const CM_OVERRIDE { return "set_target_properties"; }
 
   /**
    *  Used by this command and cmSetPropertiesCommand
diff --git a/Source/cmSetTestsPropertiesCommand.h b/Source/cmSetTestsPropertiesCommand.h
index e469b2a..712ab36 100644
--- a/Source/cmSetTestsPropertiesCommand.h
+++ b/Source/cmSetTestsPropertiesCommand.h
@@ -17,19 +17,19 @@
 class cmSetTestsPropertiesCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone() { return new cmSetTestsPropertiesCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmSetTestsPropertiesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "set_tests_properties"; }
+  std::string GetName() const CM_OVERRIDE { return "set_tests_properties"; }
 
   cmTypeMacro(cmSetTestsPropertiesCommand, cmCommand);
 
diff --git a/Source/cmSiteNameCommand.h b/Source/cmSiteNameCommand.h
index a4812f7..7a9ca9d 100644
--- a/Source/cmSiteNameCommand.h
+++ b/Source/cmSiteNameCommand.h
@@ -25,24 +25,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmSiteNameCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmSiteNameCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "site_name"; }
+  std::string GetName() const CM_OVERRIDE { return "site_name"; }
 
   cmTypeMacro(cmSiteNameCommand, cmCommand);
 };
diff --git a/Source/cmSourceGroupCommand.h b/Source/cmSourceGroupCommand.h
index 0458656..81dfad6 100644
--- a/Source/cmSourceGroupCommand.h
+++ b/Source/cmSourceGroupCommand.h
@@ -26,19 +26,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmSourceGroupCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmSourceGroupCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "source_group"; }
+  std::string GetName() const CM_OVERRIDE { return "source_group"; }
 
   cmTypeMacro(cmSourceGroupCommand, cmCommand);
 };
diff --git a/Source/cmStringCommand.h b/Source/cmStringCommand.h
index 23d482c..23dc9db 100644
--- a/Source/cmStringCommand.h
+++ b/Source/cmStringCommand.h
@@ -29,24 +29,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmStringCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmStringCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "string"; }
+  std::string GetName() const CM_OVERRIDE { return "string"; }
 
   cmTypeMacro(cmStringCommand, cmCommand);
 
diff --git a/Source/cmSubdirCommand.h b/Source/cmSubdirCommand.h
index 9da91c4..08eb9a0 100644
--- a/Source/cmSubdirCommand.h
+++ b/Source/cmSubdirCommand.h
@@ -27,19 +27,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmSubdirCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmSubdirCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "subdirs"; }
+  std::string GetName() const CM_OVERRIDE { return "subdirs"; }
 
   cmTypeMacro(cmSubdirCommand, cmCommand);
 };
diff --git a/Source/cmSubdirDependsCommand.h b/Source/cmSubdirDependsCommand.h
index a15ee3e..41b27c8 100644
--- a/Source/cmSubdirDependsCommand.h
+++ b/Source/cmSubdirDependsCommand.h
@@ -17,10 +17,10 @@
 class cmSubdirDependsCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone() { return new cmSubdirDependsCommand; }
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
-  virtual std::string GetName() const { return "subdir_depends"; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmSubdirDependsCommand; }
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
+  std::string GetName() const CM_OVERRIDE { return "subdir_depends"; }
   cmTypeMacro(cmSubdirDependsCommand, cmCommand);
 };
 
diff --git a/Source/cmTargetCompileDefinitionsCommand.h b/Source/cmTargetCompileDefinitionsCommand.h
index 29d86c5..1689a75 100644
--- a/Source/cmTargetCompileDefinitionsCommand.h
+++ b/Source/cmTargetCompileDefinitionsCommand.h
@@ -21,30 +21,36 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmTargetCompileDefinitionsCommand; }
+  cmCommand* Clone() CM_OVERRIDE
+  {
+    return new cmTargetCompileDefinitionsCommand;
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "target_compile_definitions"; }
+  std::string GetName() const CM_OVERRIDE
+  {
+    return "target_compile_definitions";
+  }
 
   cmTypeMacro(cmTargetCompileDefinitionsCommand, cmTargetPropCommandBase);
 
 private:
-  virtual void HandleImportedTarget(const std::string& tgt);
-  virtual void HandleMissingTarget(const std::string& name);
+  void HandleImportedTarget(const std::string& tgt) CM_OVERRIDE;
+  void HandleMissingTarget(const std::string& name) CM_OVERRIDE;
 
-  virtual bool HandleDirectContent(cmTarget* tgt,
-                                   const std::vector<std::string>& content,
-                                   bool prepend, bool system);
-  virtual std::string Join(const std::vector<std::string>& content);
+  bool HandleDirectContent(cmTarget* tgt,
+                           const std::vector<std::string>& content,
+                           bool prepend, bool system) CM_OVERRIDE;
+  std::string Join(const std::vector<std::string>& content) CM_OVERRIDE;
 };
 
 #endif
diff --git a/Source/cmTargetCompileFeaturesCommand.h b/Source/cmTargetCompileFeaturesCommand.h
index 3d883e9..4fae84a 100644
--- a/Source/cmTargetCompileFeaturesCommand.h
+++ b/Source/cmTargetCompileFeaturesCommand.h
@@ -16,23 +16,23 @@
 
 class cmTargetCompileFeaturesCommand : public cmTargetPropCommandBase
 {
-  virtual cmCommand* Clone() { return new cmTargetCompileFeaturesCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmTargetCompileFeaturesCommand; }
 
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
-  virtual std::string GetName() const { return "target_compile_features"; }
+  std::string GetName() const CM_OVERRIDE { return "target_compile_features"; }
 
   cmTypeMacro(cmTargetCompileFeaturesCommand, cmTargetPropCommandBase);
 
 private:
-  virtual void HandleImportedTarget(const std::string& tgt);
-  virtual void HandleMissingTarget(const std::string& name);
+  void HandleImportedTarget(const std::string& tgt) CM_OVERRIDE;
+  void HandleMissingTarget(const std::string& name) CM_OVERRIDE;
 
-  virtual bool HandleDirectContent(cmTarget* tgt,
-                                   const std::vector<std::string>& content,
-                                   bool prepend, bool system);
-  virtual std::string Join(const std::vector<std::string>& content);
+  bool HandleDirectContent(cmTarget* tgt,
+                           const std::vector<std::string>& content,
+                           bool prepend, bool system) CM_OVERRIDE;
+  std::string Join(const std::vector<std::string>& content) CM_OVERRIDE;
 };
 
 #endif
diff --git a/Source/cmTargetCompileOptionsCommand.h b/Source/cmTargetCompileOptionsCommand.h
index 231448b..7239629 100644
--- a/Source/cmTargetCompileOptionsCommand.h
+++ b/Source/cmTargetCompileOptionsCommand.h
@@ -21,30 +21,30 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmTargetCompileOptionsCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmTargetCompileOptionsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "target_compile_options"; }
+  std::string GetName() const CM_OVERRIDE { return "target_compile_options"; }
 
   cmTypeMacro(cmTargetCompileOptionsCommand, cmTargetPropCommandBase);
 
 private:
-  virtual void HandleImportedTarget(const std::string& tgt);
-  virtual void HandleMissingTarget(const std::string& name);
+  void HandleImportedTarget(const std::string& tgt) CM_OVERRIDE;
+  void HandleMissingTarget(const std::string& name) CM_OVERRIDE;
 
-  virtual bool HandleDirectContent(cmTarget* tgt,
-                                   const std::vector<std::string>& content,
-                                   bool prepend, bool system);
-  virtual std::string Join(const std::vector<std::string>& content);
+  bool HandleDirectContent(cmTarget* tgt,
+                           const std::vector<std::string>& content,
+                           bool prepend, bool system) CM_OVERRIDE;
+  std::string Join(const std::vector<std::string>& content) CM_OVERRIDE;
 };
 
 #endif
diff --git a/Source/cmTargetIncludeDirectoriesCommand.h b/Source/cmTargetIncludeDirectoriesCommand.h
index 4c907bd..ba5d980 100644
--- a/Source/cmTargetIncludeDirectoriesCommand.h
+++ b/Source/cmTargetIncludeDirectoriesCommand.h
@@ -21,34 +21,40 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmTargetIncludeDirectoriesCommand; }
+  cmCommand* Clone() CM_OVERRIDE
+  {
+    return new cmTargetIncludeDirectoriesCommand;
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "target_include_directories"; }
+  std::string GetName() const CM_OVERRIDE
+  {
+    return "target_include_directories";
+  }
 
   cmTypeMacro(cmTargetIncludeDirectoriesCommand, cmTargetPropCommandBase);
 
 private:
-  virtual void HandleImportedTarget(const std::string& tgt);
-  virtual void HandleMissingTarget(const std::string& name);
+  void HandleImportedTarget(const std::string& tgt) CM_OVERRIDE;
+  void HandleMissingTarget(const std::string& name) CM_OVERRIDE;
 
-  virtual bool HandleDirectContent(cmTarget* tgt,
-                                   const std::vector<std::string>& content,
-                                   bool prepend, bool system);
-  virtual void HandleInterfaceContent(cmTarget* tgt,
-                                      const std::vector<std::string>& content,
-                                      bool prepend, bool system);
+  bool HandleDirectContent(cmTarget* tgt,
+                           const std::vector<std::string>& content,
+                           bool prepend, bool system) CM_OVERRIDE;
+  void HandleInterfaceContent(cmTarget* tgt,
+                              const std::vector<std::string>& content,
+                              bool prepend, bool system) CM_OVERRIDE;
 
-  virtual std::string Join(const std::vector<std::string>& content);
+  std::string Join(const std::vector<std::string>& content) CM_OVERRIDE;
 };
 
 #endif
diff --git a/Source/cmTargetLinkLibrariesCommand.h b/Source/cmTargetLinkLibrariesCommand.h
index 016993d..4f58639 100644
--- a/Source/cmTargetLinkLibrariesCommand.h
+++ b/Source/cmTargetLinkLibrariesCommand.h
@@ -27,19 +27,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmTargetLinkLibrariesCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmTargetLinkLibrariesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "target_link_libraries"; }
+  std::string GetName() const CM_OVERRIDE { return "target_link_libraries"; }
 
   cmTypeMacro(cmTargetLinkLibrariesCommand, cmCommand);
 
diff --git a/Source/cmTargetSourcesCommand.h b/Source/cmTargetSourcesCommand.h
index 304e176..9073204 100644
--- a/Source/cmTargetSourcesCommand.h
+++ b/Source/cmTargetSourcesCommand.h
@@ -21,31 +21,31 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmTargetSourcesCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmTargetSourcesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "target_sources"; }
+  std::string GetName() const CM_OVERRIDE { return "target_sources"; }
 
   cmTypeMacro(cmTargetSourcesCommand, cmTargetPropCommandBase);
 
 private:
-  virtual void HandleImportedTarget(const std::string& tgt);
-  virtual void HandleMissingTarget(const std::string& name);
+  void HandleImportedTarget(const std::string& tgt) CM_OVERRIDE;
+  void HandleMissingTarget(const std::string& name) CM_OVERRIDE;
 
-  virtual bool HandleDirectContent(cmTarget* tgt,
-                                   const std::vector<std::string>& content,
-                                   bool prepend, bool system);
+  bool HandleDirectContent(cmTarget* tgt,
+                           const std::vector<std::string>& content,
+                           bool prepend, bool system) CM_OVERRIDE;
 
-  virtual std::string Join(const std::vector<std::string>& content);
+  std::string Join(const std::vector<std::string>& content) CM_OVERRIDE;
 };
 
 #endif
diff --git a/Source/cmTestGenerator.h b/Source/cmTestGenerator.h
index f946a1c..66d590e 100644
--- a/Source/cmTestGenerator.h
+++ b/Source/cmTestGenerator.h
@@ -27,18 +27,20 @@ public:
   cmTestGenerator(cmTest* test,
                   std::vector<std::string> const& configurations =
                     std::vector<std::string>());
-  virtual ~cmTestGenerator();
+  ~cmTestGenerator() CM_OVERRIDE;
 
   void Compute(cmLocalGenerator* lg);
 
 protected:
-  virtual void GenerateScriptConfigs(std::ostream& os, Indent const& indent);
-  virtual void GenerateScriptActions(std::ostream& os, Indent const& indent);
-  virtual void GenerateScriptForConfig(std::ostream& os,
-                                       const std::string& config,
-                                       Indent const& indent);
-  virtual void GenerateScriptNoConfig(std::ostream& os, Indent const& indent);
-  virtual bool NeedsScriptNoConfig() const;
+  void GenerateScriptConfigs(std::ostream& os,
+                             Indent const& indent) CM_OVERRIDE;
+  void GenerateScriptActions(std::ostream& os,
+                             Indent const& indent) CM_OVERRIDE;
+  void GenerateScriptForConfig(std::ostream& os, const std::string& config,
+                               Indent const& indent) CM_OVERRIDE;
+  void GenerateScriptNoConfig(std::ostream& os,
+                              Indent const& indent) CM_OVERRIDE;
+  bool NeedsScriptNoConfig() const CM_OVERRIDE;
   void GenerateOldStyle(std::ostream& os, Indent const& indent);
 
   cmLocalGenerator* LG;
diff --git a/Source/cmTryCompileCommand.h b/Source/cmTryCompileCommand.h
index e50d54c..abfe335 100644
--- a/Source/cmTryCompileCommand.h
+++ b/Source/cmTryCompileCommand.h
@@ -25,19 +25,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmTryCompileCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmTryCompileCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "try_compile"; }
+  std::string GetName() const CM_OVERRIDE { return "try_compile"; }
 
   cmTypeMacro(cmTryCompileCommand, cmCoreTryCompile);
 };
diff --git a/Source/cmTryRunCommand.h b/Source/cmTryRunCommand.h
index 26c0777..b8eb1de 100644
--- a/Source/cmTryRunCommand.h
+++ b/Source/cmTryRunCommand.h
@@ -25,19 +25,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmTryRunCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmTryRunCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "try_run"; }
+  std::string GetName() const CM_OVERRIDE { return "try_run"; }
 
   cmTypeMacro(cmTryRunCommand, cmCoreTryCompile);
 
diff --git a/Source/cmUnsetCommand.h b/Source/cmUnsetCommand.h
index faa8f9b..6429c10 100644
--- a/Source/cmUnsetCommand.h
+++ b/Source/cmUnsetCommand.h
@@ -25,24 +25,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmUnsetCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmUnsetCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "unset"; }
+  std::string GetName() const CM_OVERRIDE { return "unset"; }
 
   cmTypeMacro(cmUnsetCommand, cmCommand);
 };
diff --git a/Source/cmUseMangledMesaCommand.h b/Source/cmUseMangledMesaCommand.h
index 5a97a61..5a44035 100644
--- a/Source/cmUseMangledMesaCommand.h
+++ b/Source/cmUseMangledMesaCommand.h
@@ -18,11 +18,11 @@ class cmUseMangledMesaCommand : public cmCommand
 {
 public:
   cmTypeMacro(cmUseMangledMesaCommand, cmCommand);
-  virtual cmCommand* Clone() { return new cmUseMangledMesaCommand; }
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
-  virtual std::string GetName() const { return "use_mangled_mesa"; }
-  virtual bool IsScriptable() const { return true; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmUseMangledMesaCommand; }
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
+  std::string GetName() const CM_OVERRIDE { return "use_mangled_mesa"; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 protected:
   void CopyAndFullPathMesaHeader(const char* source, const char* outdir);
 };
diff --git a/Source/cmUtilitySourceCommand.h b/Source/cmUtilitySourceCommand.h
index a709de1..2eb961f 100644
--- a/Source/cmUtilitySourceCommand.h
+++ b/Source/cmUtilitySourceCommand.h
@@ -18,10 +18,10 @@ class cmUtilitySourceCommand : public cmCommand
 {
 public:
   cmTypeMacro(cmUtilitySourceCommand, cmCommand);
-  virtual cmCommand* Clone() { return new cmUtilitySourceCommand; }
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
-  virtual std::string GetName() const { return "utility_source"; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmUtilitySourceCommand; }
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
+  std::string GetName() const CM_OVERRIDE { return "utility_source"; }
 };
 
 #endif
diff --git a/Source/cmVariableRequiresCommand.h b/Source/cmVariableRequiresCommand.h
index b83f615..c4b0817 100644
--- a/Source/cmVariableRequiresCommand.h
+++ b/Source/cmVariableRequiresCommand.h
@@ -18,10 +18,10 @@ class cmVariableRequiresCommand : public cmCommand
 {
 public:
   cmTypeMacro(cmVariableRequiresCommand, cmCommand);
-  virtual cmCommand* Clone() { return new cmVariableRequiresCommand; }
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
-  virtual std::string GetName() const { return "variable_requires"; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmVariableRequiresCommand; }
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
+  std::string GetName() const CM_OVERRIDE { return "variable_requires"; }
 };
 
 #endif
diff --git a/Source/cmVariableWatchCommand.h b/Source/cmVariableWatchCommand.h
index aad53cb..1d402af 100644
--- a/Source/cmVariableWatchCommand.h
+++ b/Source/cmVariableWatchCommand.h
@@ -24,34 +24,34 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmVariableWatchCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmVariableWatchCommand; }
 
   //! Default constructor
   cmVariableWatchCommand();
 
   //! Destructor.
-  ~cmVariableWatchCommand();
+  ~cmVariableWatchCommand() CM_OVERRIDE;
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /** This command does not really have a final pass but it needs to
       stay alive since it owns variable watch callback information. */
-  virtual bool HasFinalPass() const { return true; }
+  bool HasFinalPass() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "variable_watch"; }
+  std::string GetName() const CM_OVERRIDE { return "variable_watch"; }
 
   cmTypeMacro(cmVariableWatchCommand, cmCommand);
 
diff --git a/Source/cmWhileCommand.h b/Source/cmWhileCommand.h
index 0f35be8..bd354c7 100644
--- a/Source/cmWhileCommand.h
+++ b/Source/cmWhileCommand.h
@@ -21,10 +21,10 @@ class cmWhileFunctionBlocker : public cmFunctionBlocker
 {
 public:
   cmWhileFunctionBlocker(cmMakefile* mf);
-  ~cmWhileFunctionBlocker();
-  virtual bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf,
-                                 cmExecutionStatus&);
-  virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf);
+  ~cmWhileFunctionBlocker() CM_OVERRIDE;
+  bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf,
+                         cmExecutionStatus&) CM_OVERRIDE;
+  bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf) CM_OVERRIDE;
 
   std::vector<cmListFileArgument> Args;
   std::vector<cmListFileFunction> Functions;
@@ -41,20 +41,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmWhileCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmWhileCommand; }
 
   /**
    * This overrides the default InvokeInitialPass implementation.
    * It records the arguments before expansion.
    */
-  virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
-                                 cmExecutionStatus&);
+  bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
+                         cmExecutionStatus&) CM_OVERRIDE;
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  bool InitialPass(std::vector<std::string> const&,
+                   cmExecutionStatus&) CM_OVERRIDE
   {
     return false;
   }
@@ -62,12 +63,12 @@ public:
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "while"; }
+  std::string GetName() const CM_OVERRIDE { return "while"; }
 
   cmTypeMacro(cmWhileCommand, cmCommand);
 };
diff --git a/Source/cmWriteFileCommand.h b/Source/cmWriteFileCommand.h
index b0eef9c..db24b0e 100644
--- a/Source/cmWriteFileCommand.h
+++ b/Source/cmWriteFileCommand.h
@@ -24,24 +24,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone() { return new cmWriteFileCommand; }
+  cmCommand* Clone() CM_OVERRIDE { return new cmWriteFileCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus& status);
+  bool InitialPass(std::vector<std::string> const& args,
+                   cmExecutionStatus& status) CM_OVERRIDE;
 
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const { return true; }
+  bool IsScriptable() const CM_OVERRIDE { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "write_file"; }
+  std::string GetName() const CM_OVERRIDE { return "write_file"; }
 
   cmTypeMacro(cmWriteFileCommand, cmCommand);
 };