[LLDB] Fix Clang-tidy misc-use-override warnings in source/Commands headers, unify closing inclusion guards

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6.

Please check it in if it's OK, because I don't have SVN write access.

[labath]

committed as r246628.

lldb/trunk/source/Commands/CommandObjectApropos.h

 //-------------------------------------------------------------------------
 
 class CommandObjectApropos : public CommandObjectParsed
 {
 public:
 
     CommandObjectApropos (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectApropos ();
+    ~CommandObjectApropos() override;
 
 protected:
-    virtual bool
-    DoExecute (Args& command,
-             CommandReturnObject &result);
-
-
+    bool
+    DoExecute(Args& command,
+        CommandReturnObject &result) override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectApropos_h_
+#endif // liblldb_CommandObjectApropos_h_

lldb/trunk/source/Commands/CommandObjectArgs.h

namespace lldb_private {
     public:
         
         class CommandOptions : public Options
         {
         public:
             
             CommandOptions (CommandInterpreter &interpreter);
             
-            virtual
-            ~CommandOptions ();
+            ~CommandOptions() override;
             
-            virtual Error
-            SetOptionValue (uint32_t option_idx, const char *option_arg);
+            Error
+            SetOptionValue(uint32_t option_idx, const char *option_arg) override;
             
             void
-            OptionParsingStarting ();
+            OptionParsingStarting() override;
             
             const OptionDefinition*
-            GetDefinitions ();
+            GetDefinitions() override;
             
             // Options table: Required for subclasses of Options.
             
             static OptionDefinition g_option_table[];
         };
         
         CommandObjectArgs (CommandInterpreter &interpreter);
         
-        virtual
-        ~CommandObjectArgs ();
+        ~CommandObjectArgs() override;
         
-        virtual
         Options *
-        GetOptions ();
-        
+        GetOptions() override;
         
     protected:
         
         CommandOptions m_options;
 
-        virtual bool
-        DoExecute (    Args& command,
-                 CommandReturnObject &result);
-        
+        bool
+        DoExecute(Args& command,
+      CommandReturnObject &result) override;
     };
     
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectArgs_h_
+#endif // liblldb_CommandObjectArgs_h_

lldb/trunk/source/Commands/CommandObjectBreakpoint.h

 // CommandObjectMultiwordBreakpoint
 //-------------------------------------------------------------------------
 
 class CommandObjectMultiwordBreakpoint : public CommandObjectMultiword
 {
 public:
     CommandObjectMultiwordBreakpoint (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectMultiwordBreakpoint ();
+    ~CommandObjectMultiwordBreakpoint() override;
 
     static void
     VerifyBreakpointOrLocationIDs (Args &args, Target *target, CommandReturnObject &result, BreakpointIDList *valid_ids)
     {
         VerifyIDs (args, target, true, result, valid_ids);
     }
 
     static void
     VerifyBreakpointIDs (Args &args, Target *target, CommandReturnObject &result, BreakpointIDList *valid_ids)
     {
         VerifyIDs (args, target, false, result, valid_ids);
     }
 
 private:
     static void
     VerifyIDs (Args &args, Target *target, bool allow_locations, CommandReturnObject &result, BreakpointIDList *valid_ids);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectBreakpoint_h_
+#endif // liblldb_CommandObjectBreakpoint_h_

lldb/trunk/source/Commands/CommandObjectBreakpointCommand.h

 //===-- CommandObjectBreakpointCommand.h ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_CommandObjectBreakpointCommand_h_
 #define liblldb_CommandObjectBreakpointCommand_h_
 
 // C Includes
 // C++ Includes
 
-
 // Other libraries and framework includes
 // Project includes
 
 #include "lldb/lldb-types.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 
-
 namespace lldb_private {
 
 //-------------------------------------------------------------------------
 // CommandObjectMultiwordBreakpoint
 //-------------------------------------------------------------------------
 
 class CommandObjectBreakpointCommand : public CommandObjectMultiword
 {
 public:
     CommandObjectBreakpointCommand (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectBreakpointCommand ();
-
+    ~CommandObjectBreakpointCommand() override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectBreakpointCommand_h_
+#endif // liblldb_CommandObjectBreakpointCommand_h_

lldb/trunk/source/Commands/CommandObjectBugreport.h

 // CommandObjectMultiwordBugreport
 //-------------------------------------------------------------------------
 
 class CommandObjectMultiwordBugreport : public CommandObjectMultiword
 {
 public:
     CommandObjectMultiwordBugreport(CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectMultiwordBugreport();
+    ~CommandObjectMultiwordBugreport() override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectBugreport_h_
+#endif // liblldb_CommandObjectBugreport_h_

lldb/trunk/source/Commands/CommandObjectCommands.h

 //-------------------------------------------------------------------------
 
 class CommandObjectMultiwordCommands : public CommandObjectMultiword
 {
 public:
 
     CommandObjectMultiwordCommands (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectMultiwordCommands ();
-
+    ~CommandObjectMultiwordCommands() override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectCommands_h_
+#endif // liblldb_CommandObjectCommands_h_

lldb/trunk/source/Commands/CommandObjectDisassemble.h

 {
 public:
     class CommandOptions : public Options
     {
     public:
 
         CommandOptions (CommandInterpreter &interpreter);
 
-        virtual
-        ~CommandOptions ();
+        ~CommandOptions() override;
 
-        virtual Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg);
+        Error
+        SetOptionValue(uint32_t option_idx, const char *option_arg) override;
 
         void
-        OptionParsingStarting ();
+        OptionParsingStarting() override;
 
         const OptionDefinition*
-        GetDefinitions ();
+        GetDefinitions() override;
 
         const char *
         GetPluginName ()
         {
             if (plugin_name.empty())
                 return NULL;
             return plugin_name.c_str();
         }
         
         const char *
         GetFlavorString ()
         {
             if (flavor_string.empty() || flavor_string == "default")
                 return NULL;
             return flavor_string.c_str();
         }
         
-        virtual Error
-        OptionParsingFinished ();
+        Error
+        OptionParsingFinished() override;
 
         bool show_mixed; // Show mixed source/assembly
         bool show_bytes;
         uint32_t num_lines_context;
         uint32_t num_instructions;
         bool raw;
         std::string func_name;
         bool current_function;
         lldb::addr_t start_addr;
         lldb::addr_t end_addr;
         bool at_pc;
         bool frame_line;
         std::string plugin_name;
         std::string flavor_string;
         ArchSpec arch;
         bool some_location_specified; // If no location was specified, we'll select "at_pc".  This should be set
                                       // in SetOptionValue if anything the selects a location is set.
         lldb::addr_t symbol_containing_addr;
         static OptionDefinition g_option_table[];
     };
 
     CommandObjectDisassemble (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectDisassemble ();
+    ~CommandObjectDisassemble() override;
 
-    virtual
     Options *
-    GetOptions ()
+    GetOptions() override
     {
         return &m_options;
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& command,
-             CommandReturnObject &result);
+    bool
+    DoExecute(Args& command,
+        CommandReturnObject &result) override;
 
     CommandOptions m_options;
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectDisassemble_h_
+#endif // liblldb_CommandObjectDisassemble_h_

lldb/trunk/source/Commands/CommandObjectExpression.h

 public:
 
     class CommandOptions : public OptionGroup
     {
     public:
 
         CommandOptions ();
 
-        virtual
-        ~CommandOptions ();
+        ~CommandOptions() override;
 
-        virtual uint32_t
-        GetNumDefinitions ();
+        uint32_t
+        GetNumDefinitions() override;
         
-        virtual const OptionDefinition*
-        GetDefinitions ();
+        const OptionDefinition*
+        GetDefinitions() override;
         
-        virtual Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value);
+        Error
+        SetOptionValue(CommandInterpreter &interpreter,
+           uint32_t option_idx,
+           const char *option_value) override;
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter);
+        void
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
 
         // Options table: Required for subclasses of Options.
 
         static OptionDefinition g_option_table[];
         bool        unwind_on_error;
         bool        ignore_breakpoints;
         bool        show_types;
         bool        show_summary;
         bool        debug;
         uint32_t    timeout;
         bool        try_all_threads;
         lldb::LanguageType language;
         LanguageRuntimeDescriptionDisplayVerbosity m_verbosity;
     };
 
     CommandObjectExpression (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectExpression ();
+    ~CommandObjectExpression() override;
 
-    virtual
     Options *
-    GetOptions ();
+    GetOptions() override;
 
 protected:
     
     //------------------------------------------------------------------
     // IOHandler::Delegate functions
     //------------------------------------------------------------------
-    virtual void
-    IOHandlerInputComplete (IOHandler &io_handler,
-                            std::string &line);
+    void
+    IOHandlerInputComplete(IOHandler &io_handler,
+         std::string &line) override;
 
     virtual LineStatus
     IOHandlerLinesUpdated (IOHandler &io_handler,
                            StringList &lines,
                            uint32_t line_idx,
                            Error &error);
-    virtual bool
-    DoExecute (const char *command,
-               CommandReturnObject &result);
+    bool
+    DoExecute(const char *command,
+        CommandReturnObject &result) override;
 
     bool
     EvaluateExpression (const char *expr,
                         Stream *output_stream,
                         Stream *error_stream,
                         CommandReturnObject *result = NULL);
     
     void
     GetMultilineExpression ();
 
     OptionGroupOptions m_option_group;
     OptionGroupFormat m_format_options;
     OptionGroupValueObjectDisplay m_varobj_options;
     CommandOptions m_command_options;
     uint32_t m_expr_line_count;
     std::string m_expr_lines; // Multi-line expression support
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectExpression_h_
+#endif // liblldb_CommandObjectExpression_h_

lldb/trunk/source/Commands/CommandObjectFrame.h

 //-------------------------------------------------------------------------
 
 class CommandObjectMultiwordFrame : public CommandObjectMultiword
 {
 public:
 
     CommandObjectMultiwordFrame (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectMultiwordFrame ();
-
+    ~CommandObjectMultiwordFrame() override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectFrame_h_
+#endif // liblldb_CommandObjectFrame_h_

lldb/trunk/source/Commands/CommandObjectGUI.h

 //-------------------------------------------------------------------------
 
 class CommandObjectGUI : public CommandObjectParsed
 {
 public:
 
     CommandObjectGUI (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectGUI ();
+    ~CommandObjectGUI() override;
 
 protected:
-    virtual bool
-    DoExecute (Args& args,
-               CommandReturnObject &result);
-
+    bool
+    DoExecute(Args& args,
+        CommandReturnObject &result) override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectGUI_h_
+#endif // liblldb_CommandObjectGUI_h_

lldb/trunk/source/Commands/CommandObjectHelp.h

 //-------------------------------------------------------------------------
 
 class CommandObjectHelp : public CommandObjectParsed
 {
 public:
 
     CommandObjectHelp (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectHelp ();
+    ~CommandObjectHelp() override;
 
-    virtual int
-    HandleCompletion (Args &input,
-                      int &cursor_index,
-                      int &cursor_char_position,
-                      int match_start_point,
-                      int max_return_elements,
-                      bool &word_complete,
-                      StringList &matches);
+    int
+    HandleCompletion(Args &input,
+         int &cursor_index,
+         int &cursor_char_position,
+         int match_start_point,
+         int max_return_elements,
+         bool &word_complete,
+         StringList &matches) override;
     
     class CommandOptions : public Options
     {
     public:
         
         CommandOptions (CommandInterpreter &interpreter) :
         Options (interpreter)
         {
         }
         
-        virtual
-        ~CommandOptions (){}
+        ~CommandOptions() override {}
         
-        virtual Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg)
+        Error
+        SetOptionValue(uint32_t option_idx, const char *option_arg) override
         {
             Error error;
             const int short_option = m_getopt_table[option_idx].val;
             
             switch (short_option)
             {
                 case 'a':
                     m_show_aliases = false;
                     break;
                 case 'u':
                     m_show_user_defined = false;
                     break;
                 case 'h':
                     m_show_hidden = true;
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting() override
         {
             m_show_aliases = true;
             m_show_user_defined = true;
             m_show_hidden = false;
         }
         
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions() override
         {
             return g_option_table;
         }
         
         // Options table: Required for subclasses of Options.
         
         static OptionDefinition g_option_table[];
         
         // Instance variables to hold the values for command options.
         
         bool m_show_aliases;
         bool m_show_user_defined;
         bool m_show_hidden;
     };
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions() override
     {
         return &m_options;
     }
     
 protected:
-    virtual bool
-    DoExecute (Args& command,
-             CommandReturnObject &result);
+    bool
+    DoExecute(Args& command,
+        CommandReturnObject &result) override;
     
 private:
     CommandOptions m_options;
-    
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectHelp_h_
+#endif // liblldb_CommandObjectHelp_h_

lldb/trunk/source/Commands/CommandObjectLanguage.h

 //===-- CommandObjectLanguage.h ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_CommandObjectLanguage_h_
 #define liblldb_CommandObjectLanguage_h_
 
 // C Includes
 // C++ Includes
 
-
 // Other libraries and framework includes
 // Project includes
 
 #include "lldb/lldb-types.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 
 namespace lldb_private {
     class CommandObjectLanguage : public CommandObjectMultiword
     {
     public:
         CommandObjectLanguage (CommandInterpreter &interpreter);
         
-        virtual
-        ~CommandObjectLanguage ();
+        ~CommandObjectLanguage() override;
         
-        virtual void
-        GenerateHelpText (Stream &output_stream);
+        void
+        GenerateHelpText(Stream &output_stream) override;
         
     protected:
         bool
         DoExecute (Args& command, CommandReturnObject &result);
     };
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectLanguage_h_
+#endif // liblldb_CommandObjectLanguage_h_

lldb/trunk/source/Commands/CommandObjectLog.h

 class CommandObjectLog : public CommandObjectMultiword
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     CommandObjectLog(CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectLog();
+    ~CommandObjectLog() override;
 
 private:
     //------------------------------------------------------------------
     // For CommandObjectLog only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (CommandObjectLog);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectLog_h_
+#endif // liblldb_CommandObjectLog_h_

lldb/trunk/source/Commands/CommandObjectMemory.h

 
 namespace lldb_private {
 
 class CommandObjectMemory : public CommandObjectMultiword
 {
 public:
     CommandObjectMemory (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectMemory ();
+    ~CommandObjectMemory() override;
 };
 
-
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectMemory_h_
+#endif // liblldb_CommandObjectMemory_h_

lldb/trunk/source/Commands/CommandObjectPlatform.h

 // CommandObjectPlatform
 //-------------------------------------------------------------------------
 
 class CommandObjectPlatform : public CommandObjectMultiword
 {
 public:
     CommandObjectPlatform(CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectPlatform();
+    ~CommandObjectPlatform() override;
 
-    private:
     DISALLOW_COPY_AND_ASSIGN (CommandObjectPlatform);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectPlatform_h_
+#endif // liblldb_CommandObjectPlatform_h_

lldb/trunk/source/Commands/CommandObjectPlugin.h

 //===-- CommandObjectPlugin.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_CommandObjectPlugin_h_
 #define liblldb_CommandObjectPlugin_h_
 
 // C Includes
 // C++ Includes
 
-
 // Other libraries and framework includes
 // Project includes
 
 #include "lldb/lldb-types.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 
 namespace lldb_private {
     
     class CommandObjectPlugin : public CommandObjectMultiword
     {
     public:
         CommandObjectPlugin (CommandInterpreter &interpreter);
         
-        virtual
-        ~CommandObjectPlugin ();
+        ~CommandObjectPlugin() override;
     };
     
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectPlugin_h_
+#endif // liblldb_CommandObjectPlugin_h_

lldb/trunk/source/Commands/CommandObjectProcess.h

 // CommandObjectMultiwordProcess
 //-------------------------------------------------------------------------
 
 class CommandObjectMultiwordProcess : public CommandObjectMultiword
 {
 public:
     CommandObjectMultiwordProcess (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectMultiwordProcess ();
-
+    ~CommandObjectMultiwordProcess() override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectProcess_h_
+#endif // liblldb_CommandObjectProcess_h_

lldb/trunk/source/Commands/CommandObjectQuit.h

 //-------------------------------------------------------------------------
 
 class CommandObjectQuit : public CommandObjectParsed
 {
 public:
 
     CommandObjectQuit (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectQuit ();
+    ~CommandObjectQuit() override;
 
 protected:
-    virtual bool
-    DoExecute (Args& args,
-             CommandReturnObject &result);
+    bool
+    DoExecute(Args& args,
+        CommandReturnObject &result) override;
     
     bool
     ShouldAskForConfirmation (bool& is_a_detach);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectQuit_h_
+#endif // liblldb_CommandObjectQuit_h_

lldb/trunk/source/Commands/CommandObjectRegister.h

 class CommandObjectRegister : public CommandObjectMultiword
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     CommandObjectRegister(CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectRegister();
+    ~CommandObjectRegister() override;
 
 private:
     //------------------------------------------------------------------
     // For CommandObjectRegister only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (CommandObjectRegister);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectRegister_h_
+#endif // liblldb_CommandObjectRegister_h_

lldb/trunk/source/Commands/CommandObjectSettings.h

 //-------------------------------------------------------------------------
 
 class CommandObjectMultiwordSettings : public CommandObjectMultiword
 {
 public:
 
     CommandObjectMultiwordSettings (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectMultiwordSettings ();
-
+    ~CommandObjectMultiwordSettings() override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectSettings_h_
+#endif // liblldb_CommandObjectSettings_h_

lldb/trunk/source/Commands/CommandObjectSource.h

 //-------------------------------------------------------------------------
 
 class CommandObjectMultiwordSource : public CommandObjectMultiword
 {
 public:
 
     CommandObjectMultiwordSource (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectMultiwordSource ();
-
+    ~CommandObjectMultiwordSource() override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectSource.h_h_
+#endif // liblldb_CommandObjectSource_h_

lldb/trunk/source/Commands/CommandObjectSyntax.h

 //-------------------------------------------------------------------------
 
 class CommandObjectSyntax : public CommandObjectParsed
 {
 public:
 
     CommandObjectSyntax (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectSyntax ();
+    ~CommandObjectSyntax() override;
     
 protected:
-    virtual bool
-    DoExecute (Args& command,
-             CommandReturnObject &result);
-
-
+    bool
+    DoExecute(Args& command,
+        CommandReturnObject &result) override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectSyntax_h_
+#endif // liblldb_CommandObjectSyntax_h_

lldb/trunk/source/Commands/CommandObjectTarget.h

 //-------------------------------------------------------------------------
 
 class CommandObjectMultiwordTarget : public CommandObjectMultiword
 {
 public:
 
     CommandObjectMultiwordTarget (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectMultiwordTarget ();
-
-
+    ~CommandObjectMultiwordTarget() override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectTarget_h_
+#endif // liblldb_CommandObjectTarget_h_

lldb/trunk/source/Commands/CommandObjectThread.h

 namespace lldb_private {
 
 class CommandObjectMultiwordThread : public CommandObjectMultiword
 {
 public:
 
     CommandObjectMultiwordThread (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectMultiwordThread ();
-
+    ~CommandObjectMultiwordThread() override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectThread_h_
+#endif // liblldb_CommandObjectThread_h_

lldb/trunk/source/Commands/CommandObjectType.h

 //===-- CommandObjectType.h ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_CommandObjectType_h_
 #define liblldb_CommandObjectType_h_
 
 // C Includes
 // C++ Includes
 
-
 // Other libraries and framework includes
 // Project includes
 
 #include "lldb/lldb-types.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/Options.h"
 
 namespace lldb_private {
 
 class CommandObjectType : public CommandObjectMultiword
 {
 public:
     CommandObjectType (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectType ();
+    ~CommandObjectType() override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectType_h_
+#endif // liblldb_CommandObjectType_h_

lldb/trunk/source/Commands/CommandObjectVersion.h

 //-------------------------------------------------------------------------
 
 class CommandObjectVersion : public CommandObjectParsed
 {
 public:
 
     CommandObjectVersion (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectVersion ();
+    ~CommandObjectVersion() override;
 
 protected:
-    virtual bool
-    DoExecute (Args& args,
-               CommandReturnObject &result);
-
+    bool
+    DoExecute(Args& args,
+        CommandReturnObject &result) override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectVersion_h_
+#endif // liblldb_CommandObjectVersion_h_

lldb/trunk/source/Commands/CommandObjectWatchpoint.h

 // CommandObjectMultiwordWatchpoint
 //-------------------------------------------------------------------------
 
 class CommandObjectMultiwordWatchpoint : public CommandObjectMultiword
 {
 public:
     CommandObjectMultiwordWatchpoint (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectMultiwordWatchpoint ();
+    ~CommandObjectMultiwordWatchpoint() override;
 
     static bool
     VerifyWatchpointIDs(Target *target, Args &args, std::vector<uint32_t> &wp_ids);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectWatchpoint_h_
+#endif // liblldb_CommandObjectWatchpoint_h_

lldb/trunk/source/Commands/CommandObjectWatchpointCommand.h

 //===-- CommandObjectWatchpointCommand.h ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_CommandObjectWatchpointCommand_h_
 #define liblldb_CommandObjectWatchpointCommand_h_
 
 // C Includes
 // C++ Includes
 
-
 // Other libraries and framework includes
 // Project includes
 
 #include "lldb/lldb-types.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 
 
 namespace lldb_private {
 
 //-------------------------------------------------------------------------
 // CommandObjectMultiwordWatchpoint
 //-------------------------------------------------------------------------
 
 class CommandObjectWatchpointCommand : public CommandObjectMultiword
 {
 public:
     CommandObjectWatchpointCommand (CommandInterpreter &interpreter);
 
-    virtual
-    ~CommandObjectWatchpointCommand ();
-
+    ~CommandObjectWatchpointCommand() override;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectWatchpointCommand_h_
+#endif // liblldb_CommandObjectWatchpointCommand_h_