[LLDB] Fix Clang-tidy misc-use-override warnings in some files in include/lldb/Interpreter and Host; other minor fixes.

[Eugene.Zelenko]

Summary

This is second attempt based on current code.

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.

[Eugene.Zelenko]

Ping. Please review this patch, since these files is largest source of modernize-use-override warnings warnings in LLDB code.

[labath]

looks reasonable

[clayborg]

Looks good. I would venture to say just checkin any clang tidy things that aren't changing code functionality without need for review.

lldb/trunk/include/lldb/Host/MonitoringProcessLauncher.h

 //===-- MonitoringProcessLauncher.h -----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_MonitoringProcessLauncher_h_
 #define lldb_Host_MonitoringProcessLauncher_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Host/ProcessLauncher.h"
 
 namespace lldb_private
 {
 
 class MonitoringProcessLauncher : public ProcessLauncher
 {
   public:
     explicit MonitoringProcessLauncher(std::unique_ptr<ProcessLauncher> delegate_launcher);
 
-    virtual HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info, Error &error);
+    HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info, Error &error) override;
 
   private:
     std::unique_ptr<ProcessLauncher> m_delegate_launcher;
 };
-}
 
-#endif
+} // namespace lldb_private
+
+#endif // lldb_Host_MonitoringProcessLauncher_h_

lldb/trunk/include/lldb/Host/posix/HostProcessPosix.h

 //===-- HostProcessPosix.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_HostProcesPosix_h_
 #define lldb_Host_HostProcesPosix_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/lldb-types.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Host/HostNativeProcessBase.h"
 
 namespace lldb_private
 {
 
 class FileSpec;
 
 class HostProcessPosix : public HostNativeProcessBase
 {
   public:
     HostProcessPosix();
     HostProcessPosix(lldb::process_t process);
-    virtual ~HostProcessPosix();
+    ~HostProcessPosix() override;
 
     virtual Error Signal(int signo) const;
     static Error Signal(lldb::process_t process, int signo);
 
     Error Terminate() override;
     Error GetMainModule(FileSpec &file_spec) const override;
 
     lldb::pid_t GetProcessId() const override;
     bool IsRunning() const override;
 
     HostThread StartMonitoring(HostProcess::MonitorCallback callback, void *callback_baton, bool monitor_signals) override;
 };
-}
 
-#endif
+} // namespace lldb_private
+
+#endif // lldb_Host_HostProcesPosix_h_

lldb/trunk/include/lldb/Interpreter/CommandCompletions.h

typedef enum
         eSettingsNameCompletion   = (1u << 5),
         ePlatformPluginCompletion = (1u << 6),
         eArchitectureCompletion   = (1u << 7),
         eVariablePathCompletion   = (1u << 8),
         // This item serves two purposes.  It is the last element in the enum,
         // so you can add custom enums starting from here in your Option class.
         // Also if you & in this bit the base code will not process the option.
         eCustomCompletion         = (1u << 9)
-
     } CommonCompletionTypes;
 
     struct CommonCompletionElement
     {
         uint32_t type;
         CompletionCallback callback;
     };
 
public:
     static int
     DiskFiles (CommandInterpreter &interpreter,
                const char *partial_file_name,
                int match_start_point,
                int max_return_elements,
                SearchFilter *searcher,
                bool &word_complete,
                StringList &matches);
+
     static int
     DiskDirectories (CommandInterpreter &interpreter,
                      const char *partial_file_name,
                      int match_start_point,
                      int max_return_elements,
                      SearchFilter *searcher,
                      bool &word_complete,
                      StringList &matches);
public:
     {
     public:
         Completer (CommandInterpreter &interpreter,
                    const char *completion_str,
                    int match_start_point,
                    int max_return_elements,
                    StringList &matches);
 
-        virtual ~Completer ();
+        ~Completer() override;
 
-        virtual CallbackReturn
-        SearchCallback (SearchFilter &filter,
-                        SymbolContext &context,
-                        Address *addr,
-                        bool complete) = 0;
+        CallbackReturn
+        SearchCallback(SearchFilter &filter,
+                       bool complete) override = 0;
 
-        virtual Depth
-        GetDepth () = 0;
+        Depth
+        GetDepth() override = 0;
 
         virtual size_t
         DoCompletion (SearchFilter *filter) = 0;
 
         protected:
             CommandInterpreter &m_interpreter;
             std::string m_completion_str;
             int m_match_start_point;
             int m_max_return_elements;
             StringList &m_matches;
+
         private:
-            DISALLOW_COPY_AND_ASSIGN (Completer);
+            DISALLOW_COPY_AND_ASSIGN(Completer);
     };
 
     //----------------------------------------------------------------------
     // SourceFileCompleter implements the source file completer
     //----------------------------------------------------------------------
     class SourceFileCompleter : public Completer
     {
     public:
-
         SourceFileCompleter (CommandInterpreter &interpreter,
                              bool include_support_files,
                              const char *completion_str,
                              int match_start_point,
                              int max_return_elements,
                              StringList &matches);
         
-        virtual Searcher::Depth GetDepth ();
+        Searcher::Depth GetDepth() override;
 
-        virtual Searcher::CallbackReturn
-        SearchCallback (SearchFilter &filter,
-                        SymbolContext &context,
-                        Address *addr,
-                        bool complete);
+        Searcher::CallbackReturn
+        SearchCallback(SearchFilter &filter,
+                       bool complete) override;
 
         size_t
-        DoCompletion (SearchFilter *filter);
+        DoCompletion(SearchFilter *filter) override;
 
     private:
         bool m_include_support_files;
         FileSpecList m_matching_files;
         const char *m_file_name;
         const char *m_dir_name;
-        DISALLOW_COPY_AND_ASSIGN (SourceFileCompleter);
 
+        DISALLOW_COPY_AND_ASSIGN(SourceFileCompleter);
     };
 
     //----------------------------------------------------------------------
     // ModuleCompleter implements the module completer
     //----------------------------------------------------------------------
     class ModuleCompleter : public Completer
     {
     public:
-
         ModuleCompleter (CommandInterpreter &interpreter,
                          const char *completion_str,
                          int match_start_point,
                          int max_return_elements,
                          StringList &matches);
         
-        virtual Searcher::Depth GetDepth ();
+        Searcher::Depth GetDepth() override;
 
-        virtual Searcher::CallbackReturn
-        SearchCallback (SearchFilter &filter,
-                        SymbolContext &context,
-                        Address *addr,
-                        bool complete);
+        Searcher::CallbackReturn
+        SearchCallback(SearchFilter &filter,
+                       bool complete) override;
 
         size_t
-        DoCompletion (SearchFilter *filter);
+        DoCompletion(SearchFilter *filter) override;
 
     private:
         const char *m_file_name;
         const char *m_dir_name;
-        DISALLOW_COPY_AND_ASSIGN (ModuleCompleter);
 
+        DISALLOW_COPY_AND_ASSIGN(ModuleCompleter);
     };
 
     //----------------------------------------------------------------------
     // SymbolCompleter implements the symbol completer
     //----------------------------------------------------------------------
     class SymbolCompleter : public Completer
     {
     public:
-
         SymbolCompleter (CommandInterpreter &interpreter,
                          const char *completion_str,
                          int match_start_point,
                          int max_return_elements,
                          StringList &matches);
         
-        virtual Searcher::Depth GetDepth ();
+        Searcher::Depth GetDepth() override;
 
-        virtual Searcher::CallbackReturn
-        SearchCallback (SearchFilter &filter,
-                        SymbolContext &context,
-                        Address *addr,
-                        bool complete);
+        Searcher::CallbackReturn
+        SearchCallback(SearchFilter &filter,
+                       bool complete) override;
 
         size_t
-        DoCompletion (SearchFilter *filter);
+        DoCompletion(SearchFilter *filter) override;
 
     private:
 //        struct NameCmp {
 //            bool operator() (const ConstString& lhs, const ConstString& rhs) const
 //            {
 //                return lhs < rhs;
 //            }
 //        };
 
         RegularExpression m_regex;
         typedef std::set<ConstString> collection;
         collection m_match_set;
-        DISALLOW_COPY_AND_ASSIGN (SymbolCompleter);
 
+        DISALLOW_COPY_AND_ASSIGN(SymbolCompleter);
     };
 
 private:
     static CommonCompletionElement g_common_completions[];
-
 };
 
 } // namespace lldb_private
-#endif  // lldb_CommandCompletions_h_
+
+#endif // lldb_CommandCompletions_h_

lldb/trunk/include/lldb/Interpreter/CommandHistory.h

 
 // C Includes
 // C++ Includes
 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
-
 #include "lldb/lldb-private.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
     
 class CommandHistory
 {

lldb/trunk/include/lldb/Interpreter/CommandInterpreter.h

 };
 
 class CommandInterpreter :
     public Broadcaster,
     public Properties,
     public IOHandlerDelegate
 {
 public:
-
-
     typedef std::map<std::string, OptionArgVectorSP> OptionArgMap;
 
     enum
     {
         eBroadcastBitThreadShouldExit       = (1 << 0),
         eBroadcastBitResetPrompt            = (1 << 1),
         eBroadcastBitQuitCommandReceived    = (1 << 2),   // User entered quit
         eBroadcastBitAsynchronousOutputData = (1 << 3),
public:
     {
         eCommandTypesBuiltin = 0x0001,  // native commands such as "frame"
         eCommandTypesUserDef = 0x0002,  // scripted commands
         eCommandTypesAliases = 0x0004,  // aliases such as "po"
         eCommandTypesHidden  = 0x0008,  // commands prefixed with an underscore
         eCommandTypesAllThem = 0xFFFF   // all commands
     };
 
+    CommandInterpreter(Debugger &debugger,
+                       lldb::ScriptLanguage script_language,
+                       bool synchronous_execution);
+
+    ~CommandInterpreter() override;
+
     // These two functions fill out the Broadcaster interface:
     
     static ConstString &GetStaticBroadcasterClass ();
 
-    virtual ConstString &GetBroadcasterClass() const
+    ConstString &GetBroadcasterClass() const override
     {
         return GetStaticBroadcasterClass();
     }
 
     void
     SourceInitFile (bool in_cwd, 
                     CommandReturnObject &result);
 
-    CommandInterpreter (Debugger &debugger,
-                        lldb::ScriptLanguage script_language,
-                        bool synchronous_execution);
-
-    virtual
-    ~CommandInterpreter ();
-
     bool
     AddCommand (const char *name, 
                 const lldb::CommandObjectSP &cmd_sp,
                 bool can_replace);
     
     bool
     AddUserCommand (std::string name, 
                     const lldb::CommandObjectSP &cmd_sp,
public:
     RemoveAllUser ()
     {
         m_user_dict.clear();
     }
 
     OptionArgVectorSP
     GetAliasOptions (const char *alias_name);
 
-
     bool
     ProcessAliasOptionsArgs (lldb::CommandObjectSP &cmd_obj_sp, 
                              const char *options_args,
                              OptionArgVectorSP &option_arg_vector_sp);
 
     void
     RemoveAliasOptions (const char *alias_name);
 
public:
     // point.
     // Returns:
     // -1 if the completion character should be inserted
     // -2 if the entire command line should be deleted and replaced with matches.GetStringAtIndex(0)
     // INT_MAX if the number of matches is > max_return_elements, but it is expensive to compute.
     // Otherwise, returns the number of matches.
     //
     // FIXME: Only max_return_elements == -1 is supported at present.
-
     int
     HandleCompletion (const char *current_line,
                       const char *cursor,
                       const char *last_char,
                       int match_start_point,
                       int max_return_elements,
                       StringList &matches);
 
     // This version just returns matches, and doesn't compute the substring.  It is here so the
     // Help command can call it for the first argument.
     // word_complete tells whether the completions are considered a "complete" response (so the
     // completer should complete the quote & put a space after the word.
-
     int
     HandleCompletionMatches (Args &input,
                              int &cursor_index,
                              int &cursor_char_position,
                              int match_start_point,
                              int max_return_elements,
                              bool &word_complete,
                              StringList &matches);
 
-
     int
     GetCommandNamesMatchingPartialString (const char *cmd_cstr, 
                                           bool include_aliases, 
                                           StringList &matches);
 
     void
     GetHelp (CommandReturnObject &result,
              uint32_t types = eCommandTypesAllThem);
public:
     Initialize ();
     
     void
     Clear ();
 
     void
     SetScriptLanguage (lldb::ScriptLanguage lang);
 
-
     bool
     HasCommands ();
 
     bool
     HasAliases ();
 
     bool
     HasUserCommands ();
public:
     GetSpaceReplPrompts () const;
     
 protected:
     friend class Debugger;
 
     //------------------------------------------------------------------
     // IOHandlerDelegate functions
     //------------------------------------------------------------------
-    virtual void
-    IOHandlerInputComplete (IOHandler &io_handler,
-                            std::string &line);
+    void
+    IOHandlerInputComplete(IOHandler &io_handler,
+                           std::string &line) override;
 
-    virtual ConstString
-    IOHandlerGetControlSequence (char ch)
+    ConstString
+    IOHandlerGetControlSequence(char ch) override
     {
         if (ch == 'd')
             return ConstString("quit\n");
         return ConstString();
     }
     
-    virtual bool
-    IOHandlerInterrupt (IOHandler &io_handler);
+    bool
+    IOHandlerInterrupt(IOHandler &io_handler) override;
 
     size_t
     GetProcessOutput ();
 
     void
     SetSynchronous (bool value);
 
     lldb::CommandObjectSP
     GetCommandSP (const char *cmd, bool include_aliases = true, bool exact = true, StringList *matches = NULL);
     
-    
 private:
-    
     Error
     PreprocessCommand (std::string &command);
 
     // Completely resolves aliases and abbreviations, returning a pointer to the
     // final command object and updating command_line to the fully substituted
     // and translated command.
     CommandObject *
     ResolveCommandImpl(std::string &command_line, CommandReturnObject &result);
 
-
     Debugger &m_debugger;                       // The debugger session that this interpreter is associated with
     ExecutionContextRef m_exe_ctx_ref;          // The current execution context to use when handling commands
     bool m_synchronous_execution;
     bool m_skip_lldbinit_files;
     bool m_skip_app_init_files;
     CommandObject::CommandMap m_command_dict;   // Stores basic built-in commands (they cannot be deleted, removed or overwritten).
     CommandObject::CommandMap m_alias_dict;     // Stores user aliases/abbreviations for commands
     CommandObject::CommandMap m_user_dict;      // Stores user-defined commands
     OptionArgMap m_alias_options;               // Stores any options (with or without arguments) that go with any alias.
     CommandHistory m_command_history;
     std::string m_repeat_command;               // Stores the command that will be executed for an empty command string.
     lldb::ScriptInterpreterSP m_script_interpreter_sp;
     lldb::IOHandlerSP m_command_io_handler_sp;
     char m_comment_char;
     bool m_batch_command_mode;
     ChildrenTruncatedWarningStatus m_truncation_warning;    // Whether we truncated children and whether the user has been told
     uint32_t m_command_source_depth;
     std::vector<uint32_t> m_command_source_flags;
     uint32_t m_num_errors;
     bool m_quit_requested;
     bool m_stopped_for_crash;
-    
 };
 
-
 } // namespace lldb_private
 
-#endif  // liblldb_CommandInterpreter_h_
+#endif // liblldb_CommandInterpreter_h_

lldb/trunk/include/lldb/Interpreter/CommandObject.h

 //===-- CommandObject.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_CommandObject_h_
 #define liblldb_CommandObject_h_
 
+// C Includes
+// C++ Includes
 #include <map>
-#include <set>
 #include <string>
 #include <vector>
 
+// Other libraries and framework includes
+// Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Core/StringList.h"
 #include "lldb/Core/Flags.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/ExecutionContext.h"
 
 namespace lldb_private {
 
 class CommandObject
 {
 public:
-
     typedef const char *(ArgumentHelpCallbackFunction) ();
     
     struct ArgumentHelpCallback
     {
         ArgumentHelpCallbackFunction  *help_callback;
         bool                           self_formatting;
         
         const char*
         operator () () const
         {
             return (*help_callback)();
         }
         
         explicit operator bool() const
         {
             return (help_callback != NULL);
         }
-
     };
     
     struct ArgumentTableEntry  // Entries in the main argument information table
     {
         lldb::CommandArgumentType  arg_type;
         const char *arg_name;
         CommandCompletions::CommonCompletionTypes completion_type;
         ArgumentHelpCallback  help_function;
CommandObject (CommandInterpreter &interpreter,
                    const char *name,
                    const char *help = NULL,
                    const char *syntax = NULL,
                    uint32_t flags = 0);
 
     virtual
     ~CommandObject ();
 
-    
     static const char * 
     GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type);
     
     static const char * 
     GetArgumentDescriptionAsCString (const lldb::CommandArgumentType arg_type);
 
     CommandInterpreter &
     GetCommandInterpreter ()
public:
     ///     The array of matches returned.
     ///
     /// FIXME: This is the wrong return value, since we also need to make a distinction between
     /// total number of matches, and the window the user wants returned.
     ///
     /// @return
     ///     The number of completions.
     //------------------------------------------------------------------
-
     virtual int
     HandleArgumentCompletion (Args &input,
                               int &cursor_index,
                               int &cursor_char_position,
                               OptionElementVector &opt_element_vector,
                               int match_start_point,
                               int max_return_elements,
                               bool &word_complete,
protected:
     lldb::CommandOverrideCallback m_deprecated_command_override_callback;
     lldb::CommandOverrideCallbackWithResult m_command_override_callback;
     void * m_command_override_baton;
     
     // Helper function to populate IDs or ID ranges as the command argument data
     // to the specified command argument entry.
     static void
     AddIDsArgumentData(CommandArgumentEntry &arg, lldb::CommandArgumentType ID, lldb::CommandArgumentType IDRange);
-    
 };
 
 class CommandObjectParsed : public CommandObject
 {
 public:
-
     CommandObjectParsed (CommandInterpreter &interpreter,
                          const char *name,
                          const char *help = NULL,
                          const char *syntax = NULL,
                          uint32_t flags = 0) :
         CommandObject (interpreter, name, help, syntax, flags) {}
 
-    virtual
-    ~CommandObjectParsed () {}
+    ~CommandObjectParsed() override = default;
     
-    virtual bool
-    Execute (const char *args_string, CommandReturnObject &result);
+    bool
+    Execute(const char *args_string, CommandReturnObject &result) override;
     
 protected:
     virtual bool
     DoExecute (Args& command,
              CommandReturnObject &result) = 0;
     
-    virtual bool
-    WantsRawCommandString() { return false; }
+    bool
+    WantsRawCommandString() override
+    {
+        return false;
+    }
 };
 
 class CommandObjectRaw : public CommandObject
 {
 public:
-
     CommandObjectRaw (CommandInterpreter &interpreter,
                          const char *name,
                          const char *help = NULL,
                          const char *syntax = NULL,
                          uint32_t flags = 0) :
         CommandObject (interpreter, name, help, syntax, flags) {}
 
-    virtual
-    ~CommandObjectRaw () {}
+    ~CommandObjectRaw() override = default;
     
-    virtual bool
-    Execute (const char *args_string, CommandReturnObject &result);
+    bool
+    Execute(const char *args_string, CommandReturnObject &result) override;
 
 protected:    
     virtual bool
     DoExecute (const char *command, CommandReturnObject &result) = 0;
 
-    virtual bool
-    WantsRawCommandString() { return true; }
+    bool
+    WantsRawCommandString() override
+    {
+        return true;
+    }
 };
 
-
 } // namespace lldb_private
 
-
-#endif  // liblldb_CommandObject_h_
+#endif // liblldb_CommandObject_h_

lldb/trunk/include/lldb/Interpreter/CommandObjectMultiword.h

 //===-- CommandObjectMultiword.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_CommandObjectMultiword_h_
 #define liblldb_CommandObjectMultiword_h_
 
 // C Includes
 // C++ Includes
-#include <map>
-
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Interpreter/CommandObject.h"
 
 namespace lldb_private {
 
 //-------------------------------------------------------------------------
 // CommandObjectMultiword
 //-------------------------------------------------------------------------
 
 class CommandObjectMultiword : public CommandObject
 {
 // These two want to iterate over the subcommand dictionary.
 friend class CommandInterpreter;
 friend class CommandObjectSyntax;
 public:
     CommandObjectMultiword (CommandInterpreter &interpreter,
                             const char *name,
                             const char *help = NULL,
                             const char *syntax = NULL,
                             uint32_t flags = 0);
     
-    virtual
-    ~CommandObjectMultiword ();
+    ~CommandObjectMultiword() override;
 
-    virtual bool
-    IsMultiwordObject () { return true; }
+    bool
+    IsMultiwordObject() override
+    {
+        return true;
+    }
 
-    virtual bool
-    LoadSubCommand (const char *cmd_name, 
-                    const lldb::CommandObjectSP& command_obj);
+    bool
+    LoadSubCommand(const char *cmd_name,
+                   const lldb::CommandObjectSP& command_obj) override;
 
-    virtual void
-    GenerateHelpText (Stream &output_stream);
+    void
+    GenerateHelpText(Stream &output_stream) override;
 
-    virtual lldb::CommandObjectSP
-    GetSubcommandSP (const char *sub_cmd, StringList *matches = NULL);
+    lldb::CommandObjectSP
+    GetSubcommandSP(const char *sub_cmd, StringList *matches = NULL) override;
 
-    virtual CommandObject *
-    GetSubcommandObject (const char *sub_cmd, StringList *matches = NULL);
+    CommandObject *
+    GetSubcommandObject(const char *sub_cmd, StringList *matches = NULL) override;
 
-    virtual void
-    AproposAllSubCommands (const char *prefix,
-                           const char *search_word,
-                           StringList &commands_found,
-                           StringList &commands_help);
+    void
+    AproposAllSubCommands(const char *prefix,
+                          StringList &commands_help) override;
 
-    virtual bool
-    WantsRawCommandString() { return false; }
+    bool
+    WantsRawCommandString() override
+    {
+        return false;
+    }
 
-    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,
+                     StringList &matches) override;
 
-    virtual const char *GetRepeatCommand (Args &current_command_args, uint32_t index);
+    const char *
+    GetRepeatCommand (Args &current_command_args, uint32_t index) override;
 
-    virtual bool
-    Execute (const char *args_string,
-             CommandReturnObject &result);
+    bool
+    Execute(const char *args_string,
+            CommandReturnObject &result) override;
     
-    virtual bool
-    IsRemovable() const { return m_can_be_removed; }
+    bool
+    IsRemovable() const override
+    {
+        return m_can_be_removed;
+    }
     
     void
     SetRemovable (bool removable)
     {
         m_can_be_removed = removable;
     }
     
 protected:
 
     CommandObject::CommandMap m_subcommand_dict;
     bool m_can_be_removed;
 };
     
-    
 class CommandObjectProxy : public CommandObject
 {
 public:
     CommandObjectProxy (CommandInterpreter &interpreter,
                         const char *name,
                         const char *help = NULL,
                         const char *syntax = NULL,
                         uint32_t flags = 0);
     
-    virtual
-    ~CommandObjectProxy ();
+    ~CommandObjectProxy() override;
     
     // Subclasses must provide a command object that will be transparently
     // used for this object.
     virtual CommandObject *
     GetProxyCommandObject() = 0;
 
-    virtual const char *
-    GetHelpLong ();
+    const char *
+    GetHelpLong() override;
     
-    virtual bool
-    IsRemovable() const;
+    bool
+    IsRemovable() const override;
 
-    virtual bool
-    IsMultiwordObject ();
+    bool
+    IsMultiwordObject() override;
     
-    virtual lldb::CommandObjectSP
-    GetSubcommandSP (const char *sub_cmd, StringList *matches = NULL);
+    lldb::CommandObjectSP
+    GetSubcommandSP(const char *sub_cmd, StringList *matches = NULL) override;
     
-    virtual CommandObject *
-    GetSubcommandObject (const char *sub_cmd, StringList *matches = NULL);
+    CommandObject *
+    GetSubcommandObject(const char *sub_cmd, StringList *matches = NULL) override;
     
-    virtual void
-    AproposAllSubCommands (const char *prefix,
-                           const char *search_word,
-                           StringList &commands_found,
-                           StringList &commands_help);
+    void
+    AproposAllSubCommands(const char *prefix,
+                          StringList &commands_help) override;
 
-    virtual bool
-    LoadSubCommand (const char *cmd_name,
-                    const lldb::CommandObjectSP& command_obj);
-    
-    virtual bool
-    WantsRawCommandString();
+    bool
+    LoadSubCommand(const char *cmd_name,
+                   const lldb::CommandObjectSP& command_obj) override;
     
-    virtual bool
-    WantsCompletion();
+    bool
+    WantsRawCommandString() override;
     
-    virtual Options *
-    GetOptions ();
+    bool
+    WantsCompletion() override;
     
+    Options *
+    GetOptions() 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,
+                     StringList &matches) override;
 
-    virtual int
-    HandleArgumentCompletion (Args &input,
-                              int &cursor_index,
-                              int &cursor_char_position,
-                              OptionElementVector &opt_element_vector,
-                              int match_start_point,
-                              int max_return_elements,
-                              bool &word_complete,
-                              StringList &matches);
+    int
+    HandleArgumentCompletion(Args &input,
+                             StringList &matches) override;
 
-    virtual const char *
-    GetRepeatCommand (Args &current_command_args,
-                      uint32_t index);
+    const char *
+    GetRepeatCommand(Args &current_command_args,
+                     uint32_t index) override;
 
-    virtual bool
-    Execute (const char *args_string,
-             CommandReturnObject &result);
+    bool
+    Execute(const char *args_string,
+            CommandReturnObject &result) override;
 
 protected:
-    
     // These two want to iterate over the subcommand dictionary.
     friend class CommandInterpreter;
     friend class CommandObjectSyntax;
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectMultiword_h_
+#endif // liblldb_CommandObjectMultiword_h_

lldb/trunk/include/lldb/Interpreter/CommandObjectRegexCommand.h

 
 //-------------------------------------------------------------------------
 // CommandObjectRegexCommand
 //-------------------------------------------------------------------------
 
 class CommandObjectRegexCommand : public CommandObjectRaw
 {
 public:
-
     CommandObjectRegexCommand (CommandInterpreter &interpreter,
                                const char *name, 
                                const char *help, 
                                const char *syntax, 
                                uint32_t max_matches,
                                uint32_t completion_type_mask,
                                bool is_removable);
     
-    virtual
-    ~CommandObjectRegexCommand ();
+    ~CommandObjectRegexCommand() override;
 
     bool
     IsRemovable () const override { return m_is_removable; }
 
     bool
     AddRegexCommand (const char *re_cstr, const char *command_cstr);
 
     bool
protected:
     bool m_is_removable;
 
 private:
     DISALLOW_COPY_AND_ASSIGN (CommandObjectRegexCommand);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectRegexCommand_h_
+#endif // liblldb_CommandObjectRegexCommand_h_

lldb/trunk/include/lldb/Interpreter/CommandOptionValidators.h

 //===-- CommandOptionValidators.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_CommandOptionValidators_h_
 #define liblldb_CommandOptionValidators_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/lldb-private-types.h"
 
 namespace lldb_private {
 
 class Platform;
 class ExecutionContext;
 
 class PosixPlatformCommandOptionValidator : public OptionValidator
 {
-    virtual bool IsValid(Platform &platform, const ExecutionContext &target) const;
-    virtual const char* ShortConditionString() const;
-    virtual const char* LongConditionString() const;
+    bool IsValid(Platform &platform, const ExecutionContext &target) const override;
+    const char* ShortConditionString() const override;
+    const char* LongConditionString() const override;
 };
 
 } // namespace lldb_private
 
-
-#endif  // liblldb_CommandOptionValidators_h_
+#endif // liblldb_CommandOptionValidators_h_

lldb/trunk/include/lldb/Interpreter/OptionGroupArchitecture.h

 //-------------------------------------------------------------------------
 
 class OptionGroupArchitecture : public OptionGroup
 {
 public:
     
     OptionGroupArchitecture ();
     
-    virtual
-    ~OptionGroupArchitecture ();
+    ~OptionGroupArchitecture() override;
 
+    uint32_t
+    GetNumDefinitions() override;
     
-    virtual uint32_t
-    GetNumDefinitions ();
+    const OptionDefinition*
+    GetDefinitions() override;
     
-    virtual const OptionDefinition*
-    GetDefinitions ();
-    
-    virtual Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_value);
+    Error
+    SetOptionValue(CommandInterpreter &interpreter,
+                   const char *option_value) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
     
     bool
     GetArchitecture (Platform *platform, ArchSpec &arch);
 
     bool
     ArchitectureWasSpecified () const
     {
         return !m_arch_str.empty();
     }
+
     const char *
     GetArchitectureName ()
     {
         if (m_arch_str.empty())
             return NULL;
         return m_arch_str.c_str();
     }
 
 protected:
 
     std::string m_arch_str; // Save the arch triple in case a platform is specified after the architecture
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupArchitecture_h_
+#endif // liblldb_OptionGroupArchitecture_h_

lldb/trunk/include/lldb/Interpreter/OptionGroupBoolean.h

public:
         OptionGroupBoolean (uint32_t usage_mask,
                             bool required,
                             const char *long_option, 
                             int short_option,
                             const char *usage_text,
                             bool default_value,
                             bool no_argument_toggle_default);
         
-        virtual
-        ~OptionGroupBoolean ();
-        
-        
-        virtual uint32_t
-        GetNumDefinitions ()
+        ~OptionGroupBoolean() override;
+        uint32_t
+        GetNumDefinitions() override
         {
             return 1;
         }
         
-        virtual const OptionDefinition*
-        GetDefinitions ()
+        const OptionDefinition*
+        GetDefinitions() override
         {
             return &m_option_definition;
         }
         
-        virtual Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value);
+        Error
+        SetOptionValue(CommandInterpreter &interpreter,
+                       const char *option_value) override;
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter);
+        void
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
         OptionValueBoolean &
         GetOptionValue ()
         {
             return m_value;
         }
         
         const OptionValueBoolean &
         GetOptionValue () const
         {
             return m_value;
         }
         
     protected:
         OptionValueBoolean m_value;
         OptionDefinition m_option_definition;
-        
     };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupBoolean_h_
+#endif // liblldb_OptionGroupBoolean_h_

lldb/trunk/include/lldb/Interpreter/OptionGroupFile.h

-//===-- OptionGroupFile.h -------------------------------*- C++ -*-===//
+//===-- OptionGroupFile.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

 
 //-------------------------------------------------------------------------
 // OptionGroupFile
 //-------------------------------------------------------------------------
 
 class OptionGroupFile : public OptionGroup
 {
 public:
-    
     OptionGroupFile (uint32_t usage_mask,
                      bool required,
                      const char *long_option, 
                      int short_option,
                      uint32_t completion_type,
                      lldb::CommandArgumentType argument_type,
                      const char *usage_text);
     
-    virtual
-    ~OptionGroupFile ();
-
-    
-    virtual uint32_t
-    GetNumDefinitions ()
+    ~OptionGroupFile() override;
+    uint32_t
+    GetNumDefinitions() override
     {
         return 1;
     }
     
-    virtual const OptionDefinition*
-    GetDefinitions ()
+    const OptionDefinition*
+    GetDefinitions() override
     {
         return &m_option_definition;
     }
     
-    virtual Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_value);
+    Error
+    SetOptionValue(CommandInterpreter &interpreter,
+                   const char *option_value) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
     
     OptionValueFileSpec &
     GetOptionValue ()
     {
         return m_file;
     }
 
     const OptionValueFileSpec &
     GetOptionValue () const
     {
         return m_file;
     }
 
 protected:
     OptionValueFileSpec m_file;
     OptionDefinition m_option_definition;
-    
 };
 
 //-------------------------------------------------------------------------
 // OptionGroupFileList
 //-------------------------------------------------------------------------
 
 class OptionGroupFileList : public OptionGroup
 {
 public:
     
     OptionGroupFileList (uint32_t usage_mask,
                          bool required,
                          const char *long_option, 
                          int short_option,
                          uint32_t completion_type,
                          lldb::CommandArgumentType argument_type,
                          const char *usage_text);
     
-    virtual
-    ~OptionGroupFileList ();
+    ~OptionGroupFileList() override;
     
-    
-    virtual uint32_t
-    GetNumDefinitions ()
+    uint32_t
+    GetNumDefinitions() override
     {
         return 1;
     }
     
-    virtual const OptionDefinition*
-    GetDefinitions ()
+    const OptionDefinition*
+    GetDefinitions() override
     {
         return &m_option_definition;
     }
     
-    virtual Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_value);
-    
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
+    Error
+    SetOptionValue(CommandInterpreter &interpreter,
+                   const char *option_value) override;
     
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
 
     OptionValueFileSpecList &
     GetOptionValue ()
     {
         return m_file_list;
     }
     
     const OptionValueFileSpecList &
     GetOptionValue () const
     {
         return m_file_list;
     }
     
 protected:
     OptionValueFileSpecList m_file_list;
     OptionDefinition m_option_definition;
-    
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupFile_h_
+#endif // liblldb_OptionGroupFile_h_

lldb/trunk/include/lldb/Interpreter/OptionGroupFormat.h

-//===-- OptionGroupFormat.h -------------------------------*- C++ -*-===//
+//===-- OptionGroupFormat.h -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
public:
     static const uint32_t OPTION_GROUP_GDB_FMT  = LLDB_OPT_SET_2;
     static const uint32_t OPTION_GROUP_SIZE     = LLDB_OPT_SET_3;
     static const uint32_t OPTION_GROUP_COUNT    = LLDB_OPT_SET_4;
     
     OptionGroupFormat (lldb::Format default_format, 
                        uint64_t default_byte_size = UINT64_MAX,  // Pass UINT64_MAX to disable the "--size" option
                        uint64_t default_count = UINT64_MAX);     // Pass UINT64_MAX to disable the "--count" option
     
-    virtual
-    ~OptionGroupFormat ();
+    ~OptionGroupFormat() override;
 
+    uint32_t
+    GetNumDefinitions() override;
     
-    virtual uint32_t
-    GetNumDefinitions ();
+    const OptionDefinition*
+    GetDefinitions() override;
     
-    virtual const OptionDefinition*
-    GetDefinitions ();
-    
-    virtual Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_value);
+    Error
+    SetOptionValue(CommandInterpreter &interpreter,
+                   const char *option_value) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
     
     lldb::Format
     GetFormat () const
     {
         return m_format.GetCurrentValue();
     }
 
     OptionValueFormat &
public:
     AnyOptionWasSet () const
     {
         return m_format.OptionWasSet() ||
                m_byte_size.OptionWasSet() ||
                m_count.OptionWasSet();
     }
 
 protected:
-
     bool
     ParserGDBFormatLetter (CommandInterpreter &interpreter,
                            char format_letter,
                            lldb::Format &format,
                            uint32_t &byte_size);
 
     OptionValueFormat m_format;
     OptionValueUInt64 m_byte_size;
     OptionValueUInt64 m_count;
     char m_prev_gdb_format;
     char m_prev_gdb_size;
-    
     bool m_has_gdb_format;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupFormat_h_
+#endif // liblldb_OptionGroupFormat_h_

lldb/trunk/include/lldb/Interpreter/OptionGroupOutputFile.h

-//===-- OptionGroupOutputFile.h -------------------------------*- C++ -*-===//
+//===-- OptionGroupOutputFile.h ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

 namespace lldb_private {
 //-------------------------------------------------------------------------
 // OptionGroupOutputFile
 //-------------------------------------------------------------------------
 
 class OptionGroupOutputFile : public OptionGroup
 {
 public:
-    
     OptionGroupOutputFile ();
     
-    virtual
-    ~OptionGroupOutputFile ();
-
-    
-    virtual uint32_t
-    GetNumDefinitions ();
+    ~OptionGroupOutputFile() override;
+    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,
+                   const char *option_value) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
     
     const OptionValueFileSpec &
     GetFile ()
     {
         return m_file;
     }
 
     const OptionValueBoolean &
     GetAppend ()
     {
         return m_append;
     }
     
     bool
     AnyOptionWasSet () const
     {
         return m_file.OptionWasSet() || m_append.OptionWasSet();
     }
 
 protected:
     OptionValueFileSpec m_file;
     OptionValueBoolean m_append;
-    
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupOutputFile_h_
+#endif // liblldb_OptionGroupOutputFile_h_

lldb/trunk/include/lldb/Interpreter/OptionGroupPlatform.h

 //-------------------------------------------------------------------------
 // PlatformOptionGroup
 //
 // Make platform options available to any commands that need the settings.
 //-------------------------------------------------------------------------
 class OptionGroupPlatform : public OptionGroup
 {
 public:
-    
     OptionGroupPlatform (bool include_platform_option) :
         OptionGroup(),
         m_platform_name (),
         m_sdk_sysroot (),
         m_os_version_major (UINT32_MAX),
         m_os_version_minor (UINT32_MAX),
         m_os_version_update (UINT32_MAX),
         m_include_platform_option (include_platform_option)
     {
     }
 
-    virtual
-    ~OptionGroupPlatform ()
-    {
-    }
+    ~OptionGroupPlatform() override = default;
     
-    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,
+                   const char *option_value) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
     
     lldb::PlatformSP 
     CreatePlatformWithOptions (CommandInterpreter &interpreter,
                                const ArchSpec &arch,
                                bool make_selected, 
                                Error& error,
                                ArchSpec &platform_arch) const;
 
protected:
     uint32_t m_os_version_major;
     uint32_t m_os_version_minor;
     uint32_t m_os_version_update;
     bool m_include_platform_option;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupPlatform_h_
+#endif // liblldb_OptionGroupPlatform_h_

lldb/trunk/include/lldb/Interpreter/OptionGroupString.h

-//===-- OptionGroupString.h ------------------------------------*- C++ -*-===//
+//===-- OptionGroupString.h -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

 namespace lldb_private {
     //-------------------------------------------------------------------------
     // OptionGroupString
     //-------------------------------------------------------------------------
     
     class OptionGroupString : public OptionGroup
     {
     public:
-        
         OptionGroupString (uint32_t usage_mask,
                            bool required,
                            const char *long_option, 
                            int short_option,
                            uint32_t completion_type,
                            lldb::CommandArgumentType argument_type,
                            const char *usage_text,
                            const char *default_value);
         
-        virtual
-        ~OptionGroupString ();
-        
-        
-        virtual uint32_t
-        GetNumDefinitions ()
+        ~OptionGroupString() override;
+        uint32_t
+        GetNumDefinitions() override
         {
             return 1;
         }
         
-        virtual const OptionDefinition*
-        GetDefinitions ()
+        const OptionDefinition*
+        GetDefinitions() override
         {
             return &m_option_definition;
         }
         
-        virtual Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value);
+        Error
+        SetOptionValue(CommandInterpreter &interpreter,
+                       const char *option_value) override;
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter);
+        void
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
         OptionValueString &
         GetOptionValue ()
         {
             return m_value;
         }
         
         const OptionValueString &
         GetOptionValue () const
         {
             return m_value;
         }
         
     protected:
         OptionValueString m_value;
         OptionDefinition m_option_definition;
-        
     };
     
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupString_h_
+#endif // liblldb_OptionGroupString_h_

lldb/trunk/include/lldb/Interpreter/OptionGroupUInt64.h

-//===-- OptionGroupUInt64.h ------------------------------------*- C++ -*-===//
+//===-- OptionGroupUInt64.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_OptionGroupUInt64_h_
 #define liblldb_OptionGroupUInt64_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/OptionValueUInt64.h"
 
 namespace lldb_private {
+
     //-------------------------------------------------------------------------
     // OptionGroupUInt64
     //-------------------------------------------------------------------------
     
     class OptionGroupUInt64 : public OptionGroup
     {
     public:
-        
         OptionGroupUInt64 (uint32_t usage_mask,
                            bool required,
                            const char *long_option, 
                            int short_option,
                            uint32_t completion_type,
                            lldb::CommandArgumentType argument_type,
                            const char *usage_text,
                            uint64_t default_value);
         
-        virtual
-        ~OptionGroupUInt64 ();
-        
-        
-        virtual uint32_t
-        GetNumDefinitions ()
+        ~OptionGroupUInt64() override;
+        uint32_t
+        GetNumDefinitions() override
         {
             return 1;
         }
         
-        virtual const OptionDefinition*
-        GetDefinitions ()
+        const OptionDefinition*
+        GetDefinitions() override
         {
             return &m_option_definition;
         }
         
-        virtual Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value);
+        Error
+        SetOptionValue(CommandInterpreter &interpreter,
+                       const char *option_value) override;
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter);
+        void
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
         OptionValueUInt64 &
         GetOptionValue ()
         {
             return m_value;
         }
         
         const OptionValueUInt64 &
         GetOptionValue () const
         {
             return m_value;
         }
         
     protected:
         OptionValueUInt64 m_value;
         OptionDefinition m_option_definition;
-        
     };
     
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupUInt64_h_
+#endif // liblldb_OptionGroupUInt64_h_

lldb/trunk/include/lldb/Interpreter/OptionGroupUUID.h

 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Interpreter/OptionValueUUID.h"
 
 namespace lldb_private {
+
 //-------------------------------------------------------------------------
 // OptionGroupUUID
 //-------------------------------------------------------------------------
 
 class OptionGroupUUID : public OptionGroup
 {
 public:
-    
     OptionGroupUUID ();
     
-    virtual
-    ~OptionGroupUUID ();
-
-    
-    virtual uint32_t
-    GetNumDefinitions ();
+    ~OptionGroupUUID() override;
+    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,
+                   const char *option_value) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
     
     const OptionValueUUID &
     GetOptionValue () const
     {
         return m_uuid;
     }
 
 protected:
     OptionValueUUID m_uuid;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupUUID_h_
+#endif // liblldb_OptionGroupUUID_h_

lldb/trunk/include/lldb/Interpreter/OptionGroupValueObjectDisplay.h

-//===-- OptionGroupValueObjectDisplay.h -------------------------------*- C++ -*-===//
+//===-- OptionGroupValueObjectDisplay.h -------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

 
 //-------------------------------------------------------------------------
 // OptionGroupValueObjectDisplay
 //-------------------------------------------------------------------------
 
 class OptionGroupValueObjectDisplay : public OptionGroup
 {
 public:
-    
     OptionGroupValueObjectDisplay ();
     
-    virtual
-    ~OptionGroupValueObjectDisplay ();
-
-    
-    virtual uint32_t
-    GetNumDefinitions ();
+    ~OptionGroupValueObjectDisplay() override;
+    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,
+                   const char *option_value) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
     
     bool
     AnyOptionWasSet () const
     {
-        return show_types == true ||
-               no_summary_depth  != 0 ||
-               show_location == true ||
-               flat_output == true ||
-               use_objc == true ||
+        return show_types ||
+               no_summary_depth != 0 ||
+               show_location ||
+               flat_output ||
+               use_objc ||
                max_depth != UINT32_MAX ||
                ptr_depth != 0 ||
-               use_synth == false ||
-               be_raw == true ||
-               ignore_cap == true ||
-               run_validator == true;
+               !use_synth ||
+               be_raw ||
+               ignore_cap ||
+               run_validator;
     }
     
     DumpValueObjectOptions
     GetAsDumpOptions (LanguageRuntimeDescriptionDisplayVerbosity lang_descr_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityFull,
                       lldb::Format format = lldb::eFormatDefault,
                       lldb::TypeSummaryImplSP summary_sp = lldb::TypeSummaryImplSP());
 
     bool show_types : 1,
          show_location : 1,
          flat_output : 1,
          use_objc : 1,
          use_synth : 1,
          be_raw : 1,
          ignore_cap : 1,
          run_validator : 1;
     
     uint32_t no_summary_depth;
     uint32_t max_depth;
     uint32_t ptr_depth;
     lldb::DynamicValueType use_dynamic;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupValueObjectDisplay_h_
+#endif // liblldb_OptionGroupValueObjectDisplay_h_

lldb/trunk/include/lldb/Interpreter/OptionGroupVariable.h

 
 //-------------------------------------------------------------------------
 // OptionGroupVariable
 //-------------------------------------------------------------------------
 
     class OptionGroupVariable : public OptionGroup
     {
     public:
-        
         OptionGroupVariable (bool show_frame_options);
 
-        virtual
-        ~OptionGroupVariable ();
-        
-        virtual uint32_t
-        GetNumDefinitions ();
+        ~OptionGroupVariable() override;
+        uint32_t
+        GetNumDefinitions() override;
         
-        virtual const OptionDefinition*
-        GetDefinitions ();
+        const OptionDefinition*
+        GetDefinitions() override;
         
-        virtual Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx, 
-                        const char *option_arg);
+        Error
+        SetOptionValue(CommandInterpreter &interpreter,
+                       uint32_t option_idx,
+                       const char *option_arg) override;
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter);
+        void
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
         bool include_frame_options:1,
              show_args:1,       // Frame option only (include_frame_options == true)
              show_locals:1,     // Frame option only (include_frame_options == true)
              show_globals:1,    // Frame option only (include_frame_options == true)
              use_regex:1,
              show_scope:1,
              show_decl:1;
         OptionValueString summary;            // the name of a named summary
         OptionValueString summary_string;     // a summary string
 
     private:
         DISALLOW_COPY_AND_ASSIGN(OptionGroupVariable);
     };
     
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupVariable_h_
+#endif // liblldb_OptionGroupVariable_h_

lldb/trunk/include/lldb/Interpreter/OptionGroupWatchpoint.h

 
 //-------------------------------------------------------------------------
 // OptionGroupWatchpoint
 //-------------------------------------------------------------------------
 
     class OptionGroupWatchpoint : public OptionGroup
     {
     public:
-        
+        OptionGroupWatchpoint ();
+
+        ~OptionGroupWatchpoint() override;
         static bool
         IsWatchSizeSupported(uint32_t watch_size);
 
-        OptionGroupWatchpoint ();
-
-        virtual
-        ~OptionGroupWatchpoint ();
-        
-        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_arg);
+        Error
+        SetOptionValue(CommandInterpreter &interpreter,
+                       uint32_t option_idx,
+                       const char *option_arg) override;
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter);
+        void
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
         // Note:
         // eWatchRead == LLDB_WATCH_TYPE_READ; and
         // eWatchWrite == LLDB_WATCH_TYPE_WRITE
         typedef enum WatchType {
             eWatchInvalid = 0,
             eWatchRead,
             eWatchWrite,
             eWatchReadWrite
         } WatchType;
 
         WatchType watch_type;
         uint32_t watch_size;
         bool watch_type_specified;
 
     private:
         DISALLOW_COPY_AND_ASSIGN(OptionGroupWatchpoint);
     };
     
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupWatchpoint_h_
+#endif // liblldb_OptionGroupWatchpoint_h_

lldb/trunk/include/lldb/Interpreter/Options.h

 //===-- Options.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_Options_h_
 #define liblldb_Options_h_
 
 // C Includes
-
 // C++ Includes
 #include <set>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/Interpreter/Args.h"
 
 namespace lldb_private {
 
   static inline bool
   isprint8 (int ch)
   {
       if (ch & 0xffffff00u)
           return false;
       return isprint(ch);
   }
 
-
 //----------------------------------------------------------------------
 /// @class Options Options.h "lldb/Interpreter/Options.h"
 /// @brief A command line option parsing protocol class.
 ///
 /// Options is designed to be subclassed to contain all needed
 /// options for a given command. The options can be parsed by calling:
 /// \code
 ///     Error Args::ParseOptions (Options &);

 ///             std::cout << "verbose is on" << std::endl;
 ///         }
 ///     }
 /// \endcode
 //----------------------------------------------------------------------
 class Options
 {
 public:
-
     Options (CommandInterpreter &interpreter);
 
     virtual
     ~Options ();
 
     void
     BuildGetoptTable ();
 
public:
     OptionSeen (int short_option);
 
     bool
     VerifyOptions (CommandReturnObject &result);
 
     // Verify that the options given are in the options table and can 
     // be used together, but there may be some required options that are
     // missing (used to verify options that get folded into command aliases).
-
     bool
     VerifyPartialOptions (CommandReturnObject &result);
 
     void
     OutputFormattedUsageText (Stream &strm,
                               const OptionDefinition &option_def,
                               uint32_t output_max_columns);
 
OptionParsingFinished ()
         Error error;
         return error;
     }
 };
 
     class OptionGroup
     {
     public:
-        OptionGroup () 
-        {
-        }
-        
+        OptionGroup() = default;
         virtual 
-        ~OptionGroup () 
-        {
-        }
-        
+        ~OptionGroup() = default;
         virtual uint32_t
         GetNumDefinitions () = 0;
 
         virtual const OptionDefinition*
         GetDefinitions () = 0;
         
         virtual Error
         SetOptionValue (CommandInterpreter &interpreter,
public:
             Error error;
             return error;
         }
     };
 
     class OptionGroupOptions : public Options
     {
     public:
-        
         OptionGroupOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             m_option_defs (),
             m_option_infos (),
             m_did_finalize (false)
         {
         }
         
-        virtual
-        ~OptionGroupOptions ()
-        {
-        }
-        
-        
+        ~OptionGroupOptions() override = default;
         //----------------------------------------------------------------------
         /// Append options from a OptionGroup class.
         ///
         /// Append all options from \a group using the exact same option groups
         /// that each option is defined with.
         ///
         /// @param[in] group
         ///     A group of options to take option values from and copy their 
public:
         Finalize ();
         
         bool
         DidFinalize ()
         {
             return m_did_finalize;
         }
         
-        virtual Error
-        SetOptionValue (uint32_t option_idx, 
-                        const char *option_arg);
+        Error
+        SetOptionValue(uint32_t option_idx, 
+                       const char *option_arg) override;
         
-        virtual void
-        OptionParsingStarting ();
+        void
+        OptionParsingStarting() override;
         
-        virtual Error
-        OptionParsingFinished ();
+        Error
+        OptionParsingFinished() override;
         
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions() override
         {
             assert (m_did_finalize);
             return &m_option_defs[0];
         }
         
         const OptionGroup*
         GetGroupWithOption (char short_opt);
         
         struct OptionInfo
         {
             OptionInfo (OptionGroup* g, uint32_t i) :
                 option_group (g),
                 option_index (i)
             {
             }
             OptionGroup* option_group;  // The group that this option came from
             uint32_t option_index;      // The original option index from the OptionGroup
         };
         typedef std::vector<OptionInfo> OptionInfos;
         
         std::vector<OptionDefinition> m_option_defs;
         OptionInfos m_option_infos;
         bool m_did_finalize;
     };
-    
-
 } // namespace lldb_private
 
-#endif  // liblldb_Options_h_
+#endif // liblldb_Options_h_

lldb/trunk/include/lldb/Interpreter/ScriptInterpreter.h

 //===-- ScriptInterpreter.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_ScriptInterpreter_h_
 #define liblldb_ScriptInterpreter_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/lldb-private.h"
 
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/StructuredData.h"
 
 #include "lldb/Utility/PseudoTerminal.h"
 
-
 namespace lldb_private {
     
 class ScriptInterpreterLocker
 {
 public:
     
-    ScriptInterpreterLocker ()
-    {
-    }
-    
-    virtual ~ScriptInterpreterLocker ()
-    {
-    }
+    ScriptInterpreterLocker() = default;
+    
+    virtual ~ScriptInterpreterLocker() = default;
 private:
     DISALLOW_COPY_AND_ASSIGN (ScriptInterpreterLocker);
 };
 
 class ScriptInterpreter : public PluginInterface
 {
 public:
-
     typedef enum
     {
         eScriptReturnTypeCharPtr,
         eScriptReturnTypeBool,
         eScriptReturnTypeShortInt,
         eScriptReturnTypeShortIntUnsigned,
         eScriptReturnTypeInt,
         eScriptReturnTypeIntUnsigned,
         eScriptReturnTypeLongInt,
         eScriptReturnTypeLongIntUnsigned,
         eScriptReturnTypeLongLong,
         eScriptReturnTypeLongLongUnsigned,
         eScriptReturnTypeFloat,
         eScriptReturnTypeDouble,
         eScriptReturnTypeChar,
         eScriptReturnTypeCharStrOrNone,
         eScriptReturnTypeOpaqueObject
     } ScriptReturnType;
     
     ScriptInterpreter (CommandInterpreter &interpreter, lldb::ScriptLanguage script_lang);
 
-    virtual ~ScriptInterpreter ();
+    ~ScriptInterpreter() override;
 
     struct ExecuteScriptOptions
     {
     public:
         ExecuteScriptOptions () :
             m_enable_io(true),
             m_set_lldb_globals(true),
             m_maskout_errors(true)
public:
     SetBreakpointCommandCallbackFunction (std::vector<BreakpointOptions *> &bp_options_vec,
                                   const char *function_name);
 
     /// Set a one-liner as the callback for the breakpoint.
     virtual void 
     SetBreakpointCommandCallbackFunction (BreakpointOptions *bp_options,
                                   const char *function_name)
     {
-        return;
     }
     
     /// Set a one-liner as the callback for the watchpoint.
     virtual void 
     SetWatchpointCommandCallback (WatchpointOptions *wp_options,
                                   const char *oneliner)
     {
-        return;
     }
 
     virtual bool
     GetScriptedSummary(const char *function_name, lldb::ValueObjectSP valobj, StructuredData::ObjectSP &callee_wrapper_sp,
                        const TypeSummaryOptions &options, std::string &retval)
     {
         return false;
     }
public:
     {
         error.SetErrorString("unimplemented");
         return false;
     }
     
     virtual bool
     GetDocumentationForItem (const char* item, std::string& dest)
     {
-    dest.clear();
+        dest.clear();
         return false;
     }
     
     virtual bool
     GetShortHelpForCommandObject (StructuredData::GenericSP cmd_obj_sp,
                                   std::string& dest)
     {
         dest.clear();
public:
     AcquireInterpreterLock ();
     
     const char *
     GetScriptInterpreterPtyName ();
 
     int
     GetMasterFileDescriptor ();
 
-  CommandInterpreter &
-  GetCommandInterpreter ();
+    CommandInterpreter &
+    GetCommandInterpreter();
 
     static std::string
     LanguageToString (lldb::ScriptLanguage language);
 
     virtual void
     ResetOutputFileHandle (FILE *new_fh) { } //By default, do nothing.
 
 protected:
     CommandInterpreter &m_interpreter;
     lldb::ScriptLanguage m_script_lang;
 };
 
 } // namespace lldb_private
 
-#endif // #ifndef liblldb_ScriptInterpreter_h_
+#endif // liblldb_ScriptInterpreter_h_