commands: Use override instead of virtual.

[brucem]

Summary

This removes many/most/all of the uses of virtual on functions
(but not destructors) in favor using 'override'.

[labath]

Looks good. You can also fix a couple of style issues, if you feel like it (or just keep it in mind for next time).

source/Commands/CommandObjectMemory.cpp

379–380

You might as well reformat this when you are touching it (line break after the type).

1713–1714

same here

source/Commands/CommandObjectProcess.cpp

179–180

and here

[brucem]

Flag all destructors with override as appropriate. Also fix
the couple of code formatting issues pointed out by labath.

[brucem]

Rebase forward.

source/Commands/CommandObjectBreakpoint.cpp

CommandObjectBreakpointSet (CommandInterpreter &interpreter) :
                              "breakpoint set", 
                              "Sets a breakpoint or set of breakpoints in the executable.", 
                              "breakpoint set <cmd-options>"),
         m_options (interpreter)
     {
     }
 
 
-    virtual
-    ~CommandObjectBreakpointSet () {}
+    ~CommandObjectBreakpointSet () override {}
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
 
public:
             m_skip_prologue (eLazyBoolCalculate),
             m_one_shot (false),
             m_all_files (false),
             m_move_to_nearest_code (eLazyBoolCalculate)
         {
         }
 
 
-        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':
                     {
public:
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_condition.clear();
             m_filenames.Clear();
             m_line_num = 0;
             m_column = 0;
             m_func_names.clear();
             m_func_name_type_mask = eFunctionNameTypeNone;
             m_func_regexp.clear();
public:
             m_use_dummy = false;
             m_breakpoint_names.clear();
             m_all_files = false;
             m_exception_extra_args.Clear();
             m_move_to_nearest_code = eLazyBoolCalculate;
         }
     
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
         // Options table: Required for subclasses of Options.
 
         static OptionDefinition g_option_table[];
 
public:
         bool m_use_dummy;
         bool m_all_files;
         Args m_exception_extra_args;
         LazyBool m_move_to_nearest_code;
 
     };
 
 protected:
-    virtual bool
+    bool
     DoExecute (Args& command,
-              CommandReturnObject &result)
+              CommandReturnObject &result) override
     {
         Target *target = GetSelectedOrDummyTarget(m_options.m_use_dummy);
 
         if (target == nullptr)
         {
             result.AppendError ("Invalid target.  Must set target before setting breakpoints (see 'target create' command).");
             result.SetStatus (eReturnStatusFailed);
             return false;
public:
     {
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID, eArgTypeBreakpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back (arg);   
     }
 
 
-    virtual
-    ~CommandObjectBreakpointModify () {}
+    ~CommandObjectBreakpointModify () override {}
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
 
public:
             m_name_passed (false),
             m_queue_passed (false),
             m_condition_passed (false),
             m_one_shot_passed (false),
             m_use_dummy (false)
         {
         }
 
-        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 'c':
                     if (option_arg != NULL)
public:
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_ignore_count = 0;
             m_thread_id = LLDB_INVALID_THREAD_ID;
             m_thread_id_passed = false;
             m_thread_index = UINT32_MAX;
             m_thread_index_passed = false;
             m_thread_name.clear();
             m_queue_name.clear();
             m_condition.clear();
             m_one_shot = false;
             m_enable_passed = false;
             m_queue_passed = false;
             m_name_passed = false;
             m_condition_passed = false;
             m_one_shot_passed = false;
             m_use_dummy = false;
         }
         
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
         
 
         // Options table: Required for subclasses of Options.
 
         static OptionDefinition g_option_table[];
public:
         bool m_queue_passed;
         bool m_condition_passed;
         bool m_one_shot_passed;
         bool m_use_dummy;
 
     };
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = GetSelectedOrDummyTarget(m_options.m_use_dummy);
         if (target == NULL)
         {
             result.AppendError ("Invalid target.  No existing target or breakpoints.");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
public:
     {
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID, eArgTypeBreakpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back (arg);   
     }
 
 
-    virtual
-    ~CommandObjectBreakpointEnable () {}
+    ~CommandObjectBreakpointEnable () override {}
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = GetSelectedOrDummyTarget();
         if (target == NULL)
         {
             result.AppendError ("Invalid target.  No existing target or breakpoints.");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
the second re-enables the first location."
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID, eArgTypeBreakpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back (arg);
 
     }
 
 
-    virtual
-    ~CommandObjectBreakpointDisable () {}
+    ~CommandObjectBreakpointDisable () override {}
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = GetSelectedOrDummyTarget();
         if (target == NULL)
         {
             result.AppendError ("Invalid target.  No existing target or breakpoints.");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
CommandObjectBreakpointList (CommandInterpreter &interpreter) :
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (bp_id_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
 
-    virtual
-    ~CommandObjectBreakpointList () {}
+    ~CommandObjectBreakpointList () override {}
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
     class CommandOptions : public Options
     {
     public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             m_level (lldb::eDescriptionLevelBrief),
             m_use_dummy(false)
         {
         }
 
-        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 'b':
                     m_level = lldb::eDescriptionLevelBrief;
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_level = lldb::eDescriptionLevelFull;
             m_internal = false;
             m_use_dummy = 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.
 
         lldb::DescriptionLevel m_level;
 
         bool m_internal;
         bool m_use_dummy;
     };
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = GetSelectedOrDummyTarget(m_options.m_use_dummy);
 
         if (target == NULL)
         {
             result.AppendError ("Invalid target. No current target or breakpoints.");
             result.SetStatus (eReturnStatusSuccessFinishNoResult);
             return true;
CommandObjectBreakpointClear (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "breakpoint clear", 
                              "Clears a breakpoint or set of breakpoints in the executable.", 
                              "breakpoint clear <cmd-options>"),
         m_options (interpreter)
     {
     }
 
-    virtual
-    ~CommandObjectBreakpointClear () {}
+    ~CommandObjectBreakpointClear () override {}
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             m_filename (),
             m_line_num (0)
         {
         }
 
-        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 'f':
                     m_filename.assign (option_arg);
                     break;
 
                 case 'l':
                     m_line_num = StringConvert::ToUInt32 (option_arg, 0);
                     break;
 
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_filename.clear();
             m_line_num = 0;
         }
 
         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.
 
         std::string m_filename;
         uint32_t m_line_num;
 
     };
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = GetSelectedOrDummyTarget();
         if (target == NULL)
         {
             result.AppendError ("Invalid target. No existing target or breakpoints.");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
CommandObjectBreakpointDelete (CommandInterpreter &interpreter) :
         m_options (interpreter)
     {
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID, eArgTypeBreakpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back (arg);   
     }
 
-    virtual
-    ~CommandObjectBreakpointDelete () {}
+    ~CommandObjectBreakpointDelete () override {}
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             m_use_dummy (false),
             m_force (false)
         {
         }
 
-        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 'f':
                     m_force = true;
                     break;
 
                 case 'D':
                     m_use_dummy = true;
                     break;
 
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_use_dummy = false;
             m_force = 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_use_dummy;
         bool m_force;
     };
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = GetSelectedOrDummyTarget(m_options.m_use_dummy);
 
         if (target == NULL)
         {
             result.AppendError ("Invalid target. No existing target or breakpoints.");
             result.SetStatus (eReturnStatusFailed);
             return false;
public:
     BreakpointNameOptionGroup() :
         OptionGroup(),
         m_breakpoint(LLDB_INVALID_BREAK_ID),
         m_use_dummy (false)
     {
 
     }
 
-    virtual
-    ~BreakpointNameOptionGroup ()
+    ~BreakpointNameOptionGroup () override
     {
     }
     
-    virtual uint32_t
-    GetNumDefinitions ()
+    uint32_t
+    GetNumDefinitions () override
     {
       return sizeof (g_breakpoint_name_options) / sizeof (OptionDefinition);
     }
 
-    virtual const OptionDefinition*
-    GetDefinitions ()
+    const OptionDefinition*
+    GetDefinitions () override
     {
         return g_breakpoint_name_options;
     }
 
-    virtual Error
+    Error
     SetOptionValue (CommandInterpreter &interpreter,
                     uint32_t option_idx,
-                    const char *option_value)
+                    const char *option_value) override
     {
         Error error;
         const int short_option = g_breakpoint_name_options[option_idx].short_option;
       
         switch (short_option)
         {
         case 'N':
             if (BreakpointID::StringIsBreakpointName(option_value, error) && error.Success())
SetOptionValue (CommandInterpreter &interpreter,
 
         default:
               error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
               break;
         }
         return error;
     }
 
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter)
+    void
+    OptionParsingStarting (CommandInterpreter &interpreter) override
     {
         m_name.Clear();
         m_breakpoint.Clear();
         m_use_dummy.Clear();
         m_use_dummy.SetDefaultValue(false);
     }
 
     OptionValueString m_name;
CommandObjectBreakpointNameAdd (CommandInterpreter &interpreter) :
             id_arg.arg_repetition = eArgRepeatOptional;
             arg1.push_back(id_arg);
             m_arguments.push_back (arg1);
 
             m_option_group.Append (&m_name_options, LLDB_OPT_SET_1, LLDB_OPT_SET_ALL);
             m_option_group.Finalize();
         }
 
-    virtual
-    ~CommandObjectBreakpointNameAdd () {}
+    ~CommandObjectBreakpointNameAdd () override {}
 
   Options *
-  GetOptions ()
+  GetOptions () override
   {
     return &m_option_group;
   }
   
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         if (!m_name_options.m_name.OptionWasSet())
         {
             result.SetError("No name option provided.");
             return false;
         }
 
         Target *target = GetSelectedOrDummyTarget(m_name_options.m_use_dummy.GetCurrentValue());
CommandObjectBreakpointNameDelete (CommandInterpreter &interpreter) :
         id_arg.arg_repetition = eArgRepeatOptional;
         arg1.push_back(id_arg);
         m_arguments.push_back (arg1);
 
         m_option_group.Append (&m_name_options, LLDB_OPT_SET_1, LLDB_OPT_SET_ALL);
         m_option_group.Finalize();
     }
 
-    virtual
-    ~CommandObjectBreakpointNameDelete () {}
+    ~CommandObjectBreakpointNameDelete () override {}
 
   Options *
-  GetOptions ()
+  GetOptions () override
   {
     return &m_option_group;
   }
   
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         if (!m_name_options.m_name.OptionWasSet())
         {
             result.SetError("No name option provided.");
             return false;
         }
 
         Target *target = GetSelectedOrDummyTarget(m_name_options.m_use_dummy.GetCurrentValue());
CommandObjectBreakpointNameList (CommandInterpreter &interpreter) :
                              "breakpoint name list <command-options>"),
         m_name_options(),
         m_option_group(interpreter)
     {
         m_option_group.Append (&m_name_options);
         m_option_group.Finalize();
     }
 
-    virtual
-    ~CommandObjectBreakpointNameList () {}
+    ~CommandObjectBreakpointNameList () override {}
 
   Options *
-  GetOptions ()
+  GetOptions () override
   {
     return &m_option_group;
   }
   
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = GetSelectedOrDummyTarget(m_name_options.m_use_dummy.GetCurrentValue());
 
         if (target == NULL)
         {
             result.AppendError ("Invalid target. No existing target or breakpoints.");
             result.SetStatus (eReturnStatusFailed);
             return false;
CommandObjectBreakpointName (CommandInterpreter &interpreter) :
         CommandObjectSP list_command_object (new CommandObjectBreakpointNameList (interpreter));
 
         LoadSubCommand ("add", add_command_object);
         LoadSubCommand ("delete", delete_command_object);
         LoadSubCommand ("list", list_command_object);
 
     }
 
-    virtual
-    ~CommandObjectBreakpointName ()
+    ~CommandObjectBreakpointName () override
     {
     }
 
 };
 
 
 //-------------------------------------------------------------------------
 // CommandObjectMultiwordBreakpoint

source/Commands/CommandObjectBreakpointCommand.cpp

are no syntax errors may indicate that a function was declared but never called."
 
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (bp_id_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    virtual
-    ~CommandObjectBreakpointCommandAdd () {}
+    ~CommandObjectBreakpointCommandAdd () override {}
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
-    virtual void
-    IOHandlerActivated (IOHandler &io_handler)
+    void
+    IOHandlerActivated (IOHandler &io_handler) override
     {
         StreamFileSP output_sp(io_handler.GetOutputStreamFile());
         if (output_sp)
         {
             output_sp->PutCString(g_reader_instructions);
             output_sp->Flush();
         }
     }
     
     
-    virtual void
-    IOHandlerInputComplete (IOHandler &io_handler, std::string &line)
+    void
+    IOHandlerInputComplete (IOHandler &io_handler, std::string &line) override
     {
         io_handler.SetIsDone(true);
         
         std::vector<BreakpointOptions *> *bp_options_vec = (std::vector<BreakpointOptions *> *)io_handler.GetUserData();
         for (BreakpointOptions *bp_options : *bp_options_vec)
         {
             if (!bp_options)
                 continue;
public:
             m_use_script_language (false),
             m_script_language (eScriptLanguageNone),
             m_use_one_liner (false),
             m_one_liner(),
             m_function_name()
         {
         }
 
-        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 'o':
                 m_use_one_liner = true;
public:
                 break;
 
             default:
                 break;
             }
             return error;
         }
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_use_commands = true;
             m_use_script_language = false;
             m_script_language = eScriptLanguageNone;
 
             m_use_one_liner = false;
             m_stop_on_error = true;
             m_one_liner.clear();
             m_function_name.clear();
             m_use_dummy = 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_use_commands;
         bool m_use_script_language;
         lldb::ScriptLanguage m_script_language;
 
         // Instance variables to hold the values for one_liner options.
         bool m_use_one_liner;
         std::string m_one_liner;
         bool m_stop_on_error;
         std::string m_function_name;
         bool m_use_dummy;
     };
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = GetSelectedOrDummyTarget(m_options.m_use_dummy);
 
         if (target == NULL)
         {
             result.AppendError ("There is not a current executable; there are no breakpoints to which to add commands");
             result.SetStatus (eReturnStatusFailed);
             return false;
CommandObjectBreakpointCommandDelete (CommandInterpreter &interpreter) :
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (bp_id_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
 
-    virtual
-    ~CommandObjectBreakpointCommandDelete () {}
+    ~CommandObjectBreakpointCommandDelete () override {}
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             m_use_dummy (false)
         {
         }
 
-        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 'D':
                     m_use_dummy = true;
                     break;
 
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_use_dummy = 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_use_dummy;
     };
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = GetSelectedOrDummyTarget(m_options.m_use_dummy);
 
         if (target == NULL)
         {
             result.AppendError ("There is not a current executable; there are no breakpoints from which to delete commands");
             result.SetStatus (eReturnStatusFailed);
             return false;
CommandObjectBreakpointCommandList (CommandInterpreter &interpreter) :
 
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (bp_id_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    virtual
-    ~CommandObjectBreakpointCommandList () {}
+    ~CommandObjectBreakpointCommandList () override {}
 
 protected:
-    virtual bool
+    bool
     DoExecute (Args& command,
-             CommandReturnObject &result)
+             CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
 
         if (target == NULL)
         {
             result.AppendError ("There is not a current executable; there are no breakpoints for which to list commands");
             result.SetStatus (eReturnStatusFailed);
             return false;

source/Commands/CommandObjectBugreport.cpp

CommandObjectBugreportUnwind(CommandInterpreter &interpreter) :
                             nullptr),
         m_option_group(interpreter),
         m_outfile_options()
     {
         m_option_group.Append (&m_outfile_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3);
         m_option_group.Finalize();
     }
 
-    ~CommandObjectBugreportUnwind()
+    ~CommandObjectBugreportUnwind() override
     {
     }
 
     Options *
     GetOptions() override
     {
         return &m_option_group;
     }

source/Commands/CommandObjectCommands.cpp

CommandObjectCommandsHistory(CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "command history",
                              "Dump the history of commands in this session.",
                              NULL),
         m_options (interpreter)
     {
     }
 
-    ~CommandObjectCommandsHistory () {}
+    ~CommandObjectCommandsHistory () override {}
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
 protected:
 
     class CommandOptions : public Options
     {
     public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             m_start_idx(0),
             m_stop_idx(0),
             m_count(0),
             m_clear(false)
         {
         }
 
-        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 'c':
                     error = m_count.SetValueFromString(option_arg,eVarSetOperationAssign);
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_start_idx.Clear();
             m_stop_idx.Clear();
             m_count.Clear();
             m_clear.Clear();
         }
 
         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.
 
         OptionValueUInt64 m_start_idx;
         OptionValueUInt64 m_stop_idx;
         OptionValueUInt64 m_count;
         OptionValueBoolean m_clear;
     };
     
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         if (m_options.m_clear.GetCurrentValue() && m_options.m_clear.OptionWasSet())
         {
             m_interpreter.GetCommandHistory().Clear();
             result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult);
         }
         else
         {
CommandObjectCommandsSource(CommandInterpreter &interpreter) :
         
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (file_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    ~CommandObjectCommandsSource () {}
+    ~CommandObjectCommandsSource () override {}
 
-    virtual const char*
-    GetRepeatCommand (Args &current_command_args, uint32_t index)
+    const char*
+    GetRepeatCommand (Args &current_command_args, uint32_t index) override
     {
         return "";
     }
     
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
         
         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 
                                                              CommandCompletions::eDiskFileCompletion,
                                                              completion_str.c_str(),
                                                              match_start_point,
                                                              max_return_elements,
                                                              NULL,
                                                              word_complete,
                                                              matches);
         return matches.GetSize();
     }
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
 protected:
 
     class CommandOptions : public Options
     {
     public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             m_stop_on_error (true),
             m_silent_run (false),
             m_stop_on_continue (true)
         {
         }
 
-        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 'e':
                     error = m_stop_on_error.SetValueFromString(option_arg);
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_stop_on_error.Clear();
             m_silent_run.Clear();
             m_stop_on_continue.Clear();
         }
 
         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.
 
         OptionValueBoolean m_stop_on_error;
         OptionValueBoolean m_silent_run;
         OptionValueBoolean m_stop_on_continue;
     };
     
     bool
-    DoExecute(Args& command, CommandReturnObject &result)
+    DoExecute(Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         if (argc == 1)
         {
             const char *filename = command.GetArgumentAtIndex(0);
 
             FileSpec cmd_file (filename, true);
             ExecutionContext *exe_ctx = NULL;  // Just use the default context.
Always sets a breakpoint on line 3 of whatever file is indicated.)"
         arg3.push_back (options_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
         m_arguments.push_back (arg2);
         m_arguments.push_back (arg3);
     }
 
-    ~CommandObjectCommandsAlias ()
+    ~CommandObjectCommandsAlias () override
     {
     }
 
 protected:
-    virtual bool
-    DoExecute (const char *raw_command_line, CommandReturnObject &result)
+    bool
+    DoExecute (const char *raw_command_line, CommandReturnObject &result) override
     {
         Args args (raw_command_line);
         std::string raw_command_string (raw_command_line);
         
         size_t argc = args.GetArgumentCount();
         
         if (argc < 2)
         {
CommandObjectCommandsUnalias (CommandInterpreter &interpreter) :
         
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (alias_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    ~CommandObjectCommandsUnalias()
+    ~CommandObjectCommandsUnalias() override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         CommandObject::CommandMap::iterator pos;
         CommandObject *cmd_obj;
 
         if (args.GetArgumentCount() != 0)
         {
             const char *command_name = args.GetArgumentAtIndex(0);
             cmd_obj = m_interpreter.GetCommandObject(command_name);
CommandObjectParsed (interpreter,
 
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (alias_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    ~CommandObjectCommandsDelete()
+    ~CommandObjectCommandsDelete() override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         CommandObject::CommandMap::iterator pos;
 
         if (args.GetArgumentCount() != 0)
         {
             const char *command_name = args.GetArgumentAtIndex(0);
             if (m_interpreter.CommandExists (command_name))
             {

 )" "The following example will define a regular expression command named 'f' that \
 will call 'finish' if there are no arguments, or 'frame select <frame-idx>' if \
 a number follows 'f':" R"(
 
     (lldb) command regex f s/^$/finish/ 's/([0-9]+)/frame select %1/')"
         );
     }
     
-    ~CommandObjectCommandsAddRegex()
+    ~CommandObjectCommandsAddRegex() override
     {
     }
     
     
 protected:
     
     void
     IOHandlerActivated (IOHandler &io_handler) override
private:
      {
      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 'h':
                      m_help.assign (option_arg);
                      break;
                  case 's':
                      m_syntax.assign (option_arg);
                      break;
 
                  default:
                      error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                      break;
              }
              
              return error;
          }
          
          void
-         OptionParsingStarting ()
+         OptionParsingStarting () override
          {
              m_help.clear();
              m_syntax.clear();
          }
          
          const OptionDefinition*
-         GetDefinitions ()
+         GetDefinitions () override
          {
              return g_option_table;
          }
          
          // Options table: Required for subclasses of Options.
          
          static OptionDefinition g_option_table[];
          
CommandObjectPythonFunction (CommandInterpreter &interpreter,
         else
         {
             StreamString stream;
             stream.Printf("For more information run 'help %s'",name.c_str());
             SetHelp(stream.GetData());
         }
     }
     
-    virtual
-    ~CommandObjectPythonFunction ()
+    ~CommandObjectPythonFunction () override
     {
     }
     
-    virtual bool
-    IsRemovable () const
+    bool
+    IsRemovable () const override
     {
         return true;
     }
 
     const std::string&
     GetFunctionName ()
     {
         return m_function_name;
     }
 
     ScriptedCommandSynchronicity
     GetSynchronicity ()
     {
         return m_synchro;
     }
     
-    virtual const char *
-    GetHelpLong ()
+    const char *
+    GetHelpLong () override
     {
         if (!m_fetched_help_long)
         {
             ScriptInterpreter* scripter = m_interpreter.GetScriptInterpreter();
             if (scripter)
             {
                 std::string docstring;
                 m_fetched_help_long = scripter->GetDocumentationForItem(m_function_name.c_str(),docstring);
                 if (!docstring.empty())
                     SetHelpLong(docstring);
             }
         }
         return CommandObjectRaw::GetHelpLong();
     }
     
 protected:
-    virtual bool
-    DoExecute (const char *raw_command_line, CommandReturnObject &result)
+    bool
+    DoExecute (const char *raw_command_line, CommandReturnObject &result) override
     {
         ScriptInterpreter* scripter = m_interpreter.GetScriptInterpreter();
         
         Error error;
         
         result.SetStatus(eReturnStatusInvalid);
         
         if (!scripter || scripter->RunScriptBasedCommand(m_function_name.c_str(),
public:
     {
         StreamString stream;
         stream.Printf("For more information run 'help %s'",name.c_str());
         SetHelp(stream.GetData());
         if (ScriptInterpreter* scripter = m_interpreter.GetScriptInterpreter())
             GetFlags().Set(scripter->GetFlagsForCommandObject(cmd_obj_sp));
     }
     
-    virtual
-    ~CommandObjectScriptingObject ()
+    ~CommandObjectScriptingObject () override
     {
     }
     
-    virtual bool
-    IsRemovable () const
+    bool
+    IsRemovable () const override
     {
         return true;
     }
     
     StructuredData::GenericSP
     GetImplementingObject ()
     {
         return m_cmd_obj_sp;
     }
     
     ScriptedCommandSynchronicity
     GetSynchronicity ()
     {
         return m_synchro;
     }
 
-    virtual const char *
-    GetHelp ()
+    const char *
+    GetHelp () override
     {
         if (!m_fetched_help_short)
         {
             ScriptInterpreter* scripter = m_interpreter.GetScriptInterpreter();
             if (scripter)
             {
                 std::string docstring;
                 m_fetched_help_short = scripter->GetShortHelpForCommandObject(m_cmd_obj_sp,docstring);
                 if (!docstring.empty())
                     SetHelp(docstring);
             }
         }
         return CommandObjectRaw::GetHelp();
     }
     
-    virtual const char *
-    GetHelpLong ()
+    const char *
+    GetHelpLong () override
     {
         if (!m_fetched_help_long)
         {
             ScriptInterpreter* scripter = m_interpreter.GetScriptInterpreter();
             if (scripter)
             {
                 std::string docstring;
                 m_fetched_help_long = scripter->GetLongHelpForCommandObject(m_cmd_obj_sp,docstring);
                 if (!docstring.empty())
                     SetHelpLong(docstring);
             }
         }
         return CommandObjectRaw::GetHelpLong();
     }
     
 protected:
-    virtual bool
-    DoExecute (const char *raw_command_line, CommandReturnObject &result)
+    bool
+    DoExecute (const char *raw_command_line, CommandReturnObject &result) override
     {
         ScriptInterpreter* scripter = m_interpreter.GetScriptInterpreter();
         
         Error error;
         
         result.SetStatus(eReturnStatusInvalid);
         
         if (!scripter || scripter->RunScriptBasedCommand(m_cmd_obj_sp,
CommandObjectCommandsScriptImport (CommandInterpreter &interpreter) :
         
         // There is only one variant this argument could be; put it into the argument entry.
         arg1.push_back (cmd_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
     }
     
-    ~CommandObjectCommandsScriptImport ()
+    ~CommandObjectCommandsScriptImport () override
     {
     }
     
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
         
         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 
                                                              CommandCompletions::eDiskFileCompletion,
                                                              completion_str.c_str(),
                                                              match_start_point,
                                                              max_return_elements,
                                                              NULL,
                                                              word_complete,
                                                              matches);
         return matches.GetSize();
     }
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
 protected:
     
     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 'r':
                     m_allow_reload = true;
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_allow_reload = true;
         }
         
         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_allow_reload;
     };
 
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         if (m_interpreter.GetDebugger().GetScriptLanguage() != lldb::eScriptLanguagePython)
         {
             result.AppendError ("only scripting language supported for module importing is currently Python");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
         
CommandObjectCommandsScriptAdd(CommandInterpreter &interpreter) :
         
         // There is only one variant this argument could be; put it into the argument entry.
         arg1.push_back (cmd_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
     }
     
-    ~CommandObjectCommandsScriptAdd ()
+    ~CommandObjectCommandsScriptAdd () override
     {
     }
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
 protected:
     
     class CommandOptions : public Options
     {
     public:
         
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             m_class_name(),
             m_funct_name(),
             m_short_help(),
             m_synchronicity(eScriptedCommandSynchronicitySynchronous)
         {
         }
         
-        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 'f':
                     if (option_arg)
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_class_name.clear();
             m_funct_name.clear();
             m_short_help.clear();
             m_synchronicity = eScriptedCommandSynchronicitySynchronous;
         }
         
         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.
         
         std::string m_class_name;
         std::string m_funct_name;
         std::string m_short_help;
         ScriptedCommandSynchronicity m_synchronicity;
     };
 
-    virtual void
-    IOHandlerActivated (IOHandler &io_handler)
+    void
+    IOHandlerActivated (IOHandler &io_handler) override
     {
         StreamFileSP output_sp(io_handler.GetOutputStreamFile());
         if (output_sp)
         {
             output_sp->PutCString(g_python_command_instructions);
             output_sp->Flush();
         }
     }
     
 
-    virtual void
-    IOHandlerInputComplete (IOHandler &io_handler, std::string &data)
+    void
+    IOHandlerInputComplete (IOHandler &io_handler, std::string &data) override
     {
         StreamFileSP error_sp = io_handler.GetErrorStreamFile();
         
         ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
         if (interpreter)
         {
         
             StringList lines;
IOHandlerInputComplete (IOHandler &io_handler, std::string &data) override
 
         io_handler.SetIsDone(true);
         
         
     }
 
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         
         if (m_interpreter.GetDebugger().GetScriptLanguage() != lldb::eScriptLanguagePython)
         {
             result.AppendError ("only scripting language supported for scripted commands is currently Python");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
public:
     CommandObjectCommandsScriptList(CommandInterpreter &interpreter) :
     CommandObjectParsed (interpreter,
                    "command script list",
                    "List defined scripted commands.",
                    NULL)
     {
     }
     
-    ~CommandObjectCommandsScriptList ()
+    ~CommandObjectCommandsScriptList () override
     {
     }
     
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         
         m_interpreter.GetHelp(result,
                               CommandInterpreter::eCommandTypesUserDef);
         
         result.SetStatus (eReturnStatusSuccessFinishResult);
         
         return true;
public:
     CommandObjectCommandsScriptClear(CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "command script clear",
                              "Delete all scripted commands.",
                              NULL)
     {
     }
     
-    ~CommandObjectCommandsScriptClear ()
+    ~CommandObjectCommandsScriptClear () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         
         m_interpreter.RemoveAllUser();
         
         result.SetStatus (eReturnStatusSuccessFinishResult);
         
         return true;
     }
CommandObjectCommandsScriptDelete(CommandInterpreter &interpreter) :
         
         // There is only one variant this argument could be; put it into the argument entry.
         arg1.push_back (cmd_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
     }
     
-    ~CommandObjectCommandsScriptDelete ()
+    ~CommandObjectCommandsScriptDelete () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         
         size_t argc = command.GetArgumentCount();
         
         if (argc != 1)
         {
             result.AppendError ("'command script delete' requires one argument");
             result.SetStatus (eReturnStatusFailed);
public:
     {
         LoadSubCommand ("add",    CommandObjectSP (new CommandObjectCommandsScriptAdd (interpreter)));
         LoadSubCommand ("delete", CommandObjectSP (new CommandObjectCommandsScriptDelete (interpreter)));
         LoadSubCommand ("clear",  CommandObjectSP (new CommandObjectCommandsScriptClear (interpreter)));
         LoadSubCommand ("list",   CommandObjectSP (new CommandObjectCommandsScriptList (interpreter)));
         LoadSubCommand ("import", CommandObjectSP (new CommandObjectCommandsScriptImport (interpreter)));
     }
 
-    ~CommandObjectMultiwordCommandsScript ()
+    ~CommandObjectMultiwordCommandsScript () override
     {
     }
     
 };
 
 
 #pragma mark CommandObjectMultiwordCommands
 

source/Commands/CommandObjectFrame.cpp

CommandObjectFrameInfo (CommandInterpreter &interpreter) :
                              "frame info",
                              eCommandRequiresFrame         |
                              eCommandTryTargetAPILock      |
                              eCommandProcessMustBeLaunched |
                              eCommandProcessMustBePaused   )
     {
     }
 
-    ~CommandObjectFrameInfo ()
+    ~CommandObjectFrameInfo () override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         m_exe_ctx.GetFrameRef().DumpUsingSettingsFormat (&result.GetOutputStream());
         result.SetStatus (eReturnStatusSuccessFinishResult);
         return result.Succeeded();
     }
 };
 
 #pragma mark CommandObjectFrameSelect
class CommandOptions : public Options
     public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options(interpreter)
         {
             OptionParsingStarting ();
         }
 
-        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;
             bool success = false;
             const int short_option = m_getopt_table[option_idx].val;
             switch (short_option)
             {
             case 'r':   
                 relative_frame_offset = StringConvert::ToSInt32 (option_arg, INT32_MIN, 0, &success);
                 if (!success)
                     error.SetErrorStringWithFormat ("invalid frame offset argument '%s'", option_arg);
                 break;
 
             default:
                 error.SetErrorStringWithFormat ("invalid short option character '%c'", short_option);
                 break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             relative_frame_offset = INT32_MIN;
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
         // Options table: Required for subclasses of Options.
 
         static OptionDefinition g_option_table[];
         int32_t relative_frame_offset;
CommandObjectFrameSelect (CommandInterpreter &interpreter) :
 
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (index_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    ~CommandObjectFrameSelect ()
+    ~CommandObjectFrameSelect () override
     {
     }
 
-    virtual
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
 
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         // No need to check "thread" for validity as eCommandRequiresThread ensures it is valid
         Thread *thread = m_exe_ctx.GetThreadPtr();
 
         uint32_t frame_idx = UINT32_MAX;
         if (m_options.relative_frame_offset != INT32_MIN)
         {
             // The one and only argument is a signed relative frame index
CommandObjectFrameVariable (CommandInterpreter &interpreter) :
         m_arguments.push_back (arg);
         
         m_option_group.Append (&m_option_variable, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_option_format, OptionGroupFormat::OPTION_GROUP_FORMAT | OptionGroupFormat::OPTION_GROUP_GDB_FMT, LLDB_OPT_SET_1);
         m_option_group.Append (&m_varobj_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Finalize();
     }
 
-    virtual
-    ~CommandObjectFrameVariable ()
+    ~CommandObjectFrameVariable () override
     {
     }
 
-    virtual
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_option_group;
     }
     
     
-    virtual int
+    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)
+                              StringList &matches) override
     {
         // Arguments are the standard source file completer.
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
         
         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
                                                              CommandCompletions::eVariablePathCompletion,
                                                              completion_str.c_str(),
                                                              match_start_point,
                                                              max_return_elements,
                                                              NULL,
                                                              word_complete,
                                                              matches);
         return matches.GetSize();
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         // No need to check "frame" for validity as eCommandRequiresFrame ensures it is valid
         StackFrame *frame = m_exe_ctx.GetFramePtr();
 
         Stream &s = result.GetOutputStream();
 
         bool get_file_globals = true;
         

source/Commands/CommandObjectLog.cpp

CommandObjectLogEnable(CommandInterpreter &interpreter) :
 
         arg2.push_back (category_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
         m_arguments.push_back (arg2);
     }
 
-    virtual
-    ~CommandObjectLogEnable()
+    ~CommandObjectLogEnable() override
     {
     }
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
 //    int
 //    HandleArgumentCompletion (Args &input,
 //                              int &cursor_index,
 //                              int &cursor_char_position,
public:
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             log_file (),
             log_options (0)
         {
         }
 
 
-        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 'f':  log_file.SetFile(option_arg, true);                    break;
             case 't':  log_options |= LLDB_LOG_OPTION_THREADSAFE;             break;
public:
                 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                 break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             log_file.Clear();
             log_options = 0;
         }
 
         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.
 
         FileSpec log_file;
         uint32_t log_options;
     };
 
 protected:
-    virtual bool
+    bool
     DoExecute (Args& args,
-             CommandReturnObject &result)
+             CommandReturnObject &result) override
     {
         if (args.GetArgumentCount() < 2)
         {
             result.AppendErrorWithFormat("%s takes a log channel and one or more log types.\n", m_cmd_name.c_str());
         }
         else
         {
             std::string channel(args.GetArgumentAtIndex(0));
CommandObjectLogDisable(CommandInterpreter &interpreter) :
 
         arg2.push_back (category_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
         m_arguments.push_back (arg2);
     }
 
-    virtual
-    ~CommandObjectLogDisable()
+    ~CommandObjectLogDisable() override
     {
     }
 
 protected:
-    virtual bool
+    bool
     DoExecute (Args& args,
-             CommandReturnObject &result)
+             CommandReturnObject &result) override
     {
         const size_t argc = args.GetArgumentCount();
         if (argc == 0)
         {
             result.AppendErrorWithFormat("%s takes a log channel and one or more log types.\n", m_cmd_name.c_str());
         }
         else
         {
CommandObjectLogList(CommandInterpreter &interpreter) :
         
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (channel_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    virtual
-    ~CommandObjectLogList()
+    ~CommandObjectLogList() override
     {
     }
 
 protected:
-    virtual bool
+    bool
     DoExecute (Args& args,
-             CommandReturnObject &result)
+             CommandReturnObject &result) override
     {
         const size_t argc = args.GetArgumentCount();
         if (argc == 0)
         {
             Log::ListAllLogChannels (&result.GetOutputStream());
             result.SetStatus(eReturnStatusSuccessFinishResult);
         }
         else
public:
     CommandObjectLogTimer(CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                            "log timers",
                            "Enable, disable, dump, and reset LLDB internal performance timers.",
                            "log timers < enable <depth> | disable | dump | increment <bool> | reset >")
     {
     }
 
-    virtual
-    ~CommandObjectLogTimer()
+    ~CommandObjectLogTimer() override
     {
     }
 
 protected:
-    virtual bool
+    bool
     DoExecute (Args& args,
-             CommandReturnObject &result)
+             CommandReturnObject &result) override
     {
         const size_t argc = args.GetArgumentCount();
         result.SetStatus(eReturnStatusFailed);
 
         if (argc == 1)
         {
             const char *sub_command = args.GetArgumentAtIndex(0);
 

source/Commands/CommandObjectMemory.cpp

public:
 
     OptionGroupReadMemory () :
         m_num_per_line (1,1),
         m_output_as_binary (false),
         m_view_as_type()
     {
     }
 
-    virtual
-    ~OptionGroupReadMemory ()
+    ~OptionGroupReadMemory () override
     {
     }
     
     
-    virtual uint32_t
-    GetNumDefinitions ()
+    uint32_t
+    GetNumDefinitions () override
     {
         return sizeof (g_option_table) / sizeof (OptionDefinition);
     }
     
-    virtual const OptionDefinition*
-    GetDefinitions ()
+    const OptionDefinition*
+    GetDefinitions () override
     {
         return g_option_table;
     }
     
-    virtual Error
+    Error
     SetOptionValue (CommandInterpreter &interpreter,
                     uint32_t option_idx,
-                    const char *option_arg)
+                    const char *option_arg) override
     {
         Error error;
         const int short_option = g_option_table[option_idx].short_option;
         
         switch (short_option)
         {
             case 'l':
                 error = m_num_per_line.SetValueFromString (option_arg);
SetOptionValue (CommandInterpreter &interpreter,
                 
             default:
                 error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
                 break;
         }
         return error;
     }
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter)
+    void
+    OptionParsingStarting (CommandInterpreter &interpreter) override
     {
         m_num_per_line.Clear();
         m_output_as_binary = false;
         m_view_as_type.Clear();
         m_force = false;
     }
     
     Error
CommandObjectMemoryRead (CommandInterpreter &interpreter) :
                                OptionGroupFormat::OPTION_GROUP_SIZE, 
                                LLDB_OPT_SET_1 | LLDB_OPT_SET_2);
         m_option_group.Append (&m_memory_options);
         m_option_group.Append (&m_outfile_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3);
         m_option_group.Append (&m_varobj_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_3);
         m_option_group.Finalize();
     }
 
-    virtual
-    ~CommandObjectMemoryRead ()
+    ~CommandObjectMemoryRead () override
     {
     }
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_option_group;
     }
 
-    virtual const char *GetRepeatCommand (Args &current_command_args, uint32_t index)
+    const char *
+    GetRepeatCommand (Args &current_command_args, uint32_t index) override
     {
         return m_cmd_name.c_str();
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         // No need to check "target" for validity as eCommandRequiresTarget ensures it is valid
         Target *target = m_exe_ctx.GetTargetPtr();
 
         const size_t argc = command.GetArgumentCount();
 
         if ((argc == 0 && m_next_addr == LLDB_INVALID_ADDRESS) || argc > 2)
         {
public:
   public:
     OptionGroupFindMemory () :
       OptionGroup(),
       m_count(1),
       m_offset(0)
     {
     }
     
-    virtual
-    ~OptionGroupFindMemory ()
+    ~OptionGroupFindMemory () override
     {
     }
     
-    virtual uint32_t
-    GetNumDefinitions ()
+    uint32_t
+    GetNumDefinitions () override
     {
       return sizeof (g_memory_find_option_table) / sizeof (OptionDefinition);
     }
     
-    virtual const OptionDefinition*
-    GetDefinitions ()
+    const OptionDefinition*
+    GetDefinitions () override
     {
       return g_memory_find_option_table;
     }
     
-    virtual Error
+    Error
     SetOptionValue (CommandInterpreter &interpreter,
                     uint32_t option_idx,
-                    const char *option_arg)
+                    const char *option_arg) override
     {
         Error error;
         const int short_option = g_memory_find_option_table[option_idx].short_option;
       
         switch (short_option)
         {
         case 'e':
               m_expr.SetValueFromString(option_arg);
SetOptionValue (CommandInterpreter &interpreter,
 
         default:
               error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
               break;
         }
         return error;
     }
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter)
+    void
+    OptionParsingStarting (CommandInterpreter &interpreter) override
     {
         m_expr.Clear();
         m_string.Clear();
         m_count.Clear();
     }
     
       OptionValueString m_expr;
       OptionValueString m_string;
m_memory_options ()
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back (arg1);
     m_arguments.push_back (arg2);
     
     m_option_group.Append (&m_memory_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_2);
     m_option_group.Finalize();
   }
   
-  virtual
-  ~CommandObjectMemoryFind ()
+  ~CommandObjectMemoryFind () override
   {
   }
   
   Options *
-  GetOptions ()
+  GetOptions () override
   {
     return &m_option_group;
   }
   
 protected:
-  virtual bool
-  DoExecute (Args& command, CommandReturnObject &result)
+  bool
+  DoExecute (Args& command, CommandReturnObject &result) override
   {
       // No need to check "process" for validity as eCommandRequiresProcess ensures it is valid
       Process *process = m_exe_ctx.GetProcessPtr();
 
       const size_t argc = command.GetArgumentCount();
 
       if (argc != 2)
       {
public:
     class OptionGroupWriteMemory : public OptionGroup
     {
     public:
         OptionGroupWriteMemory () :
             OptionGroup()
         {
         }
 
-        virtual
-        ~OptionGroupWriteMemory ()
+        ~OptionGroupWriteMemory () override
         {
         }
 
-        virtual uint32_t
-        GetNumDefinitions ()
+        uint32_t
+        GetNumDefinitions () override
         {
             return sizeof (g_memory_write_option_table) / sizeof (OptionDefinition);
         }
       
-        virtual const OptionDefinition*
-        GetDefinitions ()
+        const OptionDefinition*
+        GetDefinitions () override
         {
             return g_memory_write_option_table;
         }
       
-        virtual Error
+        Error
         SetOptionValue (CommandInterpreter &interpreter,
                         uint32_t option_idx,
-                        const char *option_arg)
+                        const char *option_arg) override
         {
             Error error;
             const int short_option = g_memory_write_option_table[option_idx].short_option;
           
             switch (short_option)
             {
                 case 'i':
                     m_infile.SetFile (option_arg, true);
public:
                     
                 default:
                     error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
                     break;
             }
             return error;
         }
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter)
+        void
+        OptionParsingStarting (CommandInterpreter &interpreter) override
         {
             m_infile.Clear();
             m_infile_offset = 0;
         }
 
         FileSpec m_infile;
         off_t m_infile_offset;
     };
CommandObjectMemoryWrite (CommandInterpreter &interpreter) :
         
         m_option_group.Append (&m_format_options, OptionGroupFormat::OPTION_GROUP_FORMAT, LLDB_OPT_SET_1);
         m_option_group.Append (&m_format_options, OptionGroupFormat::OPTION_GROUP_SIZE  , LLDB_OPT_SET_1|LLDB_OPT_SET_2);
         m_option_group.Append (&m_memory_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_2);
         m_option_group.Finalize();
 
     }
 
-    virtual
-    ~CommandObjectMemoryWrite ()
+    ~CommandObjectMemoryWrite () override
     {
     }
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_option_group;
     }
 
     bool
     UIntValueIsValidForSize (uint64_t uval64, size_t total_byte_size)
     {
         if (total_byte_size > 8)
SIntValueIsValidForSize (int64_t sval64, size_t total_byte_size)
             return true;
 
         const int64_t max = ((int64_t)1 << (uint64_t)(total_byte_size * 8 - 1)) - 1;
         const int64_t min = ~(max);
         return min <= sval64 && sval64 <= max;
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         // No need to check "process" for validity as eCommandRequiresProcess ensures it is valid
         Process *process = m_exe_ctx.GetProcessPtr();
 
         const size_t argc = command.GetArgumentCount();
 
         if (m_memory_options.m_infile)
         {
CommandObjectParsed (interpreter,
         
         // There is only one variant this argument could be; put it into the argument entry.
         arg1.push_back (addr_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
     }
     
-    virtual
-    ~CommandObjectMemoryHistory ()
+    ~CommandObjectMemoryHistory () override
     {
     }
     
-    virtual const char *GetRepeatCommand (Args &current_command_args, uint32_t index)
+    const char *
+    GetRepeatCommand (Args &current_command_args, uint32_t index) override
     {
         return m_cmd_name.c_str();
     }
     
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         if (argc == 0 || argc > 1)
         {
             result.AppendErrorWithFormat ("%s takes an address expression", m_cmd_name.c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;

source/Commands/CommandObjectPlatform.cpp

 
 class OptionPermissions : public lldb_private::OptionGroup
 {
 public:
     OptionPermissions ()
     {
     }
     
-    virtual
-    ~OptionPermissions ()
+    ~OptionPermissions () override
     {
     }
     
-    virtual lldb_private::Error
+    lldb_private::Error
     SetOptionValue (CommandInterpreter &interpreter,
                     uint32_t option_idx,
-                    const char *option_arg)
+                    const char *option_arg) override
     {
         Error error;
         char short_option = (char) GetDefinitions()[option_idx].short_option;
         switch (short_option)
         {
             case 'v':
             {
                 bool ok;
SetOptionValue (CommandInterpreter &interpreter,
                 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                 break;
         }
         
         return error;
     }
     
     void
-    OptionParsingStarting (CommandInterpreter &interpreter)
+    OptionParsingStarting (CommandInterpreter &interpreter) override
     {
         m_permissions = 0;
     }
     
-    virtual uint32_t
-    GetNumDefinitions ()
+    uint32_t
+    GetNumDefinitions () override
     {
         return llvm::array_lengthof(g_permissions_options);
     }
     
     const lldb_private::OptionDefinition*
-    GetDefinitions ()
+    GetDefinitions () override
     {
         return g_permissions_options;
     }
         
     // Instance variables to hold the values for command options.
     
     uint32_t m_permissions;
 private:
CommandObjectPlatformSelect (CommandInterpreter &interpreter) :
                              0),
         m_option_group (interpreter),
         m_platform_options (false) // Don't include the "--platform" option by passing false
     {
         m_option_group.Append (&m_platform_options, LLDB_OPT_SET_ALL, 1);
         m_option_group.Finalize();
     }
 
-    virtual
-    ~CommandObjectPlatformSelect ()
+    ~CommandObjectPlatformSelect () override
     {
     }
 
-    virtual int
+    int
     HandleCompletion (Args &input,
                       int &cursor_index,
                       int &cursor_char_position,
                       int match_start_point,
                       int max_return_elements,
                       bool &word_complete,
-                      StringList &matches)
+                      StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
         
         CommandCompletions::PlatformPluginNames (m_interpreter, 
                                                  completion_str.c_str(),
                                                  match_start_point,
                                                  max_return_elements,
                                                  NULL,
                                                  word_complete,
                                                  matches);
         return matches.GetSize();
     }
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_option_group;
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         if (args.GetArgumentCount() == 1)
         {
             const char *platform_name = args.GetArgumentAtIndex (0);
             if (platform_name && platform_name[0])
             {
                 const bool select = true;
                 m_platform_options.SetPlatformName (platform_name);
CommandObjectPlatformList (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "platform list",
                              "List all platforms that are available.",
                              NULL,
                              0)
     {
     }
 
-    virtual
-    ~CommandObjectPlatformList ()
+    ~CommandObjectPlatformList () override
     {
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         Stream &ostrm = result.GetOutputStream();
         ostrm.Printf("Available platforms:\n");
         
         PlatformSP host_platform_sp (Platform::GetHostPlatform());
         ostrm.Printf ("%s: %s\n", 
                       host_platform_sp->GetPluginName().GetCString(),
                       host_platform_sp->GetDescription());
CommandObjectPlatformStatus (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "platform status",
                              "Display status for the currently selected platform.",
                              NULL,
                              0)
     {
     }
 
-    virtual
-    ~CommandObjectPlatformStatus ()
+    ~CommandObjectPlatformStatus () override
     {
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         Stream &ostrm = result.GetOutputStream();      
         
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         PlatformSP platform_sp;
         if (target)
         {
             platform_sp = target->GetPlatform();
CommandObjectPlatformConnect (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter, 
                              "platform connect",
                              "Connect a platform by name to be the currently selected platform.",
                              "platform connect <connect-url>",
                              0)
     {
     }
 
-    virtual
-    ~CommandObjectPlatformConnect ()
+    ~CommandObjectPlatformConnect () override
     {
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         Stream &ostrm = result.GetOutputStream();      
         
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         if (platform_sp)
         {
             Error error (platform_sp->ConnectRemote (args));
             if (error.Success())
DoExecute (Args& args, CommandReturnObject &result) override
         else
         {
             result.AppendError ("no platform is currently selected\n");
             result.SetStatus (eReturnStatusFailed);            
         }
         return result.Succeeded();
     }
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         OptionGroupOptions* m_platform_options = NULL;
         if (platform_sp)
         {
             m_platform_options = platform_sp->GetConnectionOptions(m_interpreter);
             if (m_platform_options != NULL && !m_platform_options->m_did_finalize)
                 m_platform_options->Finalize();
CommandObjectPlatformDisconnect (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter, 
                              "platform disconnect",
                              "Disconnect a platform by name to be the currently selected platform.",
                              "platform disconnect",
                              0)
     {
     }
 
-    virtual
-    ~CommandObjectPlatformDisconnect ()
+    ~CommandObjectPlatformDisconnect () override
     {
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         if (platform_sp)
         {
             if (args.GetArgumentCount() == 0)
             {
                 Error error;
                 
CommandObjectPlatformSettings (CommandInterpreter &interpreter) :
                              "platform settings",
                              0),
         m_options (interpreter),
         m_option_working_dir (LLDB_OPT_SET_1, false, "working-dir", 'w', 0, eArgTypePath, "The working directory for the platform.")
     {
         m_options.Append (&m_option_working_dir, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     }
     
-    virtual
-    ~CommandObjectPlatformSettings ()
+    ~CommandObjectPlatformSettings () override
     {
     }
     
 protected:
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         if (platform_sp)
         {
             if (m_option_working_dir.GetOptionValue().OptionWasSet())
                 platform_sp->SetWorkingDirectory(m_option_working_dir.GetOptionValue().GetCurrentValue());
         }
         else
         {
             result.AppendError ("no platform is currently selected");
             result.SetStatus (eReturnStatusFailed);
         }
         return result.Succeeded();
     }
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         if (m_options.DidFinalize() == false)
             m_options.Finalize();
         return &m_options;
     }
 protected:
     
     OptionGroupOptions m_options;
CommandObjectParsed (interpreter,
                          "platform mkdir",
                          "Make a new directory on the remote end.",
                          NULL,
                          0),
     m_options(interpreter)
     {
     }
     
-    virtual
-    ~CommandObjectPlatformMkDir ()
+    ~CommandObjectPlatformMkDir () override
     {
     }
     
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         if (platform_sp)
         {
             std::string cmd_line;
             args.GetCommandString(cmd_line);
             uint32_t mode;
             const OptionPermissions* options_permissions = (const OptionPermissions*)m_options.GetGroupWithOption('r');
DoExecute (Args& args, CommandReturnObject &result) override
         else
         {
             result.AppendError ("no platform currently selected\n");
             result.SetStatus (eReturnStatusFailed);
         }
         return result.Succeeded();
     }
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         if (m_options.DidFinalize() == false)
         {
             m_options.Append(new OptionPermissions());
             m_options.Finalize();
         }
         return &m_options;
     }
CommandObjectParsed (interpreter,
                          "platform file open",
                          "Open a file on the remote end.",
                          NULL,
                          0),
     m_options(interpreter)
     {
     }
     
-    virtual
-    ~CommandObjectPlatformFOpen ()
+    ~CommandObjectPlatformFOpen () override
     {
     }
     
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         if (platform_sp)
         {
             Error error;
             std::string cmd_line;
             args.GetCommandString(cmd_line);
             mode_t perms;
DoExecute (Args& args, CommandReturnObject &result) override
         }
         else
         {
             result.AppendError ("no platform currently selected\n");
             result.SetStatus (eReturnStatusFailed);
         }
         return result.Succeeded();
     }
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         if (m_options.DidFinalize() == false)
         {
             m_options.Append(new OptionPermissions());
             m_options.Finalize();
         }
         return &m_options;
     }
public:
     CommandObjectParsed (interpreter,
                          "platform file close",
                          "Close a file on the remote end.",
                          NULL,
                          0)
     {
     }
     
-    virtual
-    ~CommandObjectPlatformFClose ()
+    ~CommandObjectPlatformFClose () override
     {
     }
     
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         if (platform_sp)
         {
             std::string cmd_line;
             args.GetCommandString(cmd_line);
             const lldb::user_id_t fd = StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
             Error error;
CommandObjectParsed (interpreter,
                          "platform file read",
                          "Read data from a file on the remote end.",
                          NULL,
                          0),
     m_options (interpreter)
     {
     }
     
-    virtual
-    ~CommandObjectPlatformFRead ()
+    ~CommandObjectPlatformFRead () override
     {
     }
     
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         if (platform_sp)
         {
             std::string cmd_line;
             args.GetCommandString(cmd_line);
             const lldb::user_id_t fd = StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
             std::string buffer(m_options.m_count,0);
             Error error;
             uint32_t retcode = platform_sp->ReadFile(fd, m_options.m_offset, &buffer[0], m_options.m_count, error);
             result.AppendMessageWithFormat("Return = %d\n",retcode);
             result.AppendMessageWithFormat("Data = \"%s\"\n",buffer.c_str());
             result.SetStatus (eReturnStatusSuccessFinishResult);
         }
         else
         {
             result.AppendError ("no platform currently selected\n");
             result.SetStatus (eReturnStatusFailed);
         }
         return result.Succeeded();
     }
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
 protected:
     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;
             char short_option = (char) m_getopt_table[option_idx].val;
             bool success = false;
             
             switch (short_option)
             {
                 case 'o':
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_offset = 0;
             m_count = 1;
         }
         
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
         
         // Options table: Required for subclasses of Options.
         
         static OptionDefinition g_option_table[];
         
CommandObjectParsed (interpreter,
                          "platform file write",
                          "Write data to a file on the remote end.",
                          NULL,
                          0),
     m_options (interpreter)
     {
     }
     
-    virtual
-    ~CommandObjectPlatformFWrite ()
+    ~CommandObjectPlatformFWrite () override
     {
     }
     
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         if (platform_sp)
         {
             std::string cmd_line;
             args.GetCommandString(cmd_line);
             Error error;
             const lldb::user_id_t fd = StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
             uint32_t retcode = platform_sp->WriteFile (fd,
                                                        m_options.m_offset,
                                                        &m_options.m_data[0],
                                                        m_options.m_data.size(),
                                                        error);
             result.AppendMessageWithFormat("Return = %d\n",retcode);
             result.SetStatus (eReturnStatusSuccessFinishResult);
         }
         else
         {
             result.AppendError ("no platform currently selected\n");
             result.SetStatus (eReturnStatusFailed);
         }
         return result.Succeeded();
     }
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
 protected:
     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;
             char short_option = (char) m_getopt_table[option_idx].val;
             bool success = false;
             
             switch (short_option)
             {
                 case 'o':
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_offset = 0;
             m_data.clear();
         }
         
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
         
         // Options table: Required for subclasses of Options.
         
         static OptionDefinition g_option_table[];
         
CommandObjectMultiword (interpreter,
                             "platform file [open|close|read|write] ...")
     {
         LoadSubCommand ("open", CommandObjectSP (new CommandObjectPlatformFOpen  (interpreter)));
         LoadSubCommand ("close", CommandObjectSP (new CommandObjectPlatformFClose  (interpreter)));
         LoadSubCommand ("read", CommandObjectSP (new CommandObjectPlatformFRead  (interpreter)));
         LoadSubCommand ("write", CommandObjectSP (new CommandObjectPlatformFWrite  (interpreter)));
     }
     
-    virtual
-    ~CommandObjectPlatformFile ()
+    ~CommandObjectPlatformFile () override
     {
     }
     
 private:
     //------------------------------------------------------------------
     // For CommandObjectPlatform only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (CommandObjectPlatformFile);
Transfer a file from the remote end with file path /the/remote/file/path to the local host.)"
         // There is only one variant this argument could be; put it into the argument entry.
         arg2.push_back (file_arg_host);
 
         // Push the data for the first and the second arguments into the m_arguments vector.
         m_arguments.push_back (arg1);
         m_arguments.push_back (arg2);
     }
     
-    virtual
-    ~CommandObjectPlatformGetFile ()
+    ~CommandObjectPlatformGetFile () override
     {
     }
     
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         // If the number of arguments is incorrect, issue an error message.
         if (args.GetArgumentCount() != 2)
         {
             result.GetErrorStream().Printf("error: required arguments missing; specify both the source and destination file paths\n");
             result.SetStatus(eReturnStatusFailed);
             return false;
         }
Get the file size from the remote end with path /the/remote/file/path.)"
         file_arg_remote.arg_repetition = eArgRepeatPlain;
         // There is only one variant this argument could be; put it into the argument entry.
         arg1.push_back (file_arg_remote);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
     }
     
-    virtual
-    ~CommandObjectPlatformGetSize ()
+    ~CommandObjectPlatformGetSize () override
     {
     }
     
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         // If the number of arguments is incorrect, issue an error message.
         if (args.GetArgumentCount() != 1)
         {
             result.GetErrorStream().Printf("error: required argument missing; specify the source file path as the only argument\n");
             result.SetStatus(eReturnStatusFailed);
             return false;
         }
public:
     CommandObjectParsed (interpreter,
                          "platform put-file",
                          "Transfer a file from this system to the remote end.",
                          NULL,
                          0)
     {
     }
     
-    virtual
-    ~CommandObjectPlatformPutFile ()
+    ~CommandObjectPlatformPutFile () override
     {
     }
     
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         const char* src = args.GetArgumentAtIndex(0);
         const char* dst = args.GetArgumentAtIndex(1);
 
         FileSpec src_fs(src, true);
         FileSpec dst_fs(dst ? dst : src_fs.GetFilename().GetCString(), false);
 
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
CommandObjectPlatformProcessLaunch (CommandInterpreter &interpreter) :
                              "platform process launch",
                              "Launch a new process on a remote platform.",
                              "platform process launch program",
                              eCommandRequiresTarget | eCommandTryTargetAPILock),
         m_options (interpreter)
     {
     }
     
-    virtual
-    ~CommandObjectPlatformProcessLaunch ()
+    ~CommandObjectPlatformProcessLaunch () override
     {
     }
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
 protected:
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         PlatformSP platform_sp;
         if (target)
         {   
             platform_sp = target->GetPlatform();
         }   
         if (!platform_sp)
CommandObjectPlatformProcessList (CommandInterpreter &interpreter) :
                              "platform process list",
                              "List processes on a remote platform by name, pid, or many other matching attributes.",
                              "platform process list",
                              0),
         m_options (interpreter)
     {
     }
     
-    virtual
-    ~CommandObjectPlatformProcessList ()
+    ~CommandObjectPlatformProcessList () override
     {
     }
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
 protected:
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         PlatformSP platform_sp;
         if (target)
         {   
             platform_sp = target->GetPlatform();
         }   
         if (!platform_sp)
protected:
     public:
         
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             match_info ()
         {
         }
         
-        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;
             bool success = false;
 
             switch (short_option)
             {
                 case 'p':
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             match_info.Clear();
             show_args = false;
             verbose = false;
         }
         
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
         
         // Options table: Required for subclasses of Options.
         
         static OptionDefinition g_option_table[];
         
CommandObjectParsed (interpreter,
         
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (pid_args);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
     
-    virtual
-    ~CommandObjectPlatformProcessInfo ()
+    ~CommandObjectPlatformProcessInfo () override
     {
     }
     
 protected:
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         PlatformSP platform_sp;
         if (target)
         {   
             platform_sp = target->GetPlatform();
         }   
         if (!platform_sp)
public:
         
         CommandOptions (CommandInterpreter &interpreter) :
         Options(interpreter)
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
             OptionParsingStarting ();
         }
         
-        ~CommandOptions ()
+        ~CommandOptions () override
         {
         }
         
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg)
+        SetOptionValue (uint32_t option_idx, const char *option_arg) override
         {
             Error error;
             char short_option = (char) m_getopt_table[option_idx].val;
             bool success = false;
             switch (short_option)
             {
                 case 'p':   
                 {
public:
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             attach_info.Clear();
         }
         
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
         
-        virtual bool
+        bool
         HandleOptionArgumentCompletion (Args &input,
                                         int cursor_index,
                                         int char_pos,
                                         OptionElementVector &opt_element_vector,
                                         int opt_element_index,
                                         int match_start_point,
                                         int max_return_elements,
                                         bool &word_complete,
-                                        StringList &matches)
+                                        StringList &matches) override
         {
             int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
             int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
             
             // We are only completing the name option for now...
             
             const OptionDefinition *opt_defs = GetDefinitions();
             if (opt_defs[opt_defs_index].short_option == 'n')
public:
     CommandObjectParsed (interpreter,
                          "platform process attach",
                          "Attach to a process.",
                          "platform process attach <cmd-options>"),
     m_options (interpreter)
     {
     }
     
-    ~CommandObjectPlatformProcessAttach ()
+    ~CommandObjectPlatformProcessAttach () override
     {
     }
     
     bool
     DoExecute (Args& command,
-             CommandReturnObject &result)
+             CommandReturnObject &result) override
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         if (platform_sp)
         {
             Error err;
             ProcessSP remote_process_sp =
             platform_sp->Attach(m_options.attach_info, m_interpreter.GetDebugger(), NULL, err);
             if (err.Fail())
DoExecute (Args& command,
         {
             result.AppendError ("no platform is currently selected");
             result.SetStatus (eReturnStatusFailed);            
         }
         return result.Succeeded();
     }
     
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
     
 protected:
     
     CommandOptions m_options;
 };
public:
     {
         LoadSubCommand ("attach", CommandObjectSP (new CommandObjectPlatformProcessAttach (interpreter)));
         LoadSubCommand ("launch", CommandObjectSP (new CommandObjectPlatformProcessLaunch (interpreter)));
         LoadSubCommand ("info"  , CommandObjectSP (new CommandObjectPlatformProcessInfo (interpreter)));
         LoadSubCommand ("list"  , CommandObjectSP (new CommandObjectPlatformProcessList (interpreter)));
 
     }
     
-    virtual
-    ~CommandObjectPlatformProcess ()
+    ~CommandObjectPlatformProcess () override
     {
     }
     
 private:
     //------------------------------------------------------------------
     // For CommandObjectPlatform only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (CommandObjectPlatformProcess);
public:
     public:
         
         CommandOptions (CommandInterpreter &interpreter) :
         Options(interpreter),
         timeout(10)
         {
         }
         
-        virtual
-        ~CommandOptions ()
+        ~CommandOptions () override
         {
         }
         
         virtual uint32_t
         GetNumDefinitions ()
         {
             return 1;
         }
         
-        virtual const OptionDefinition*
-        GetDefinitions ()
+        const OptionDefinition*
+        GetDefinitions () override
         {
             return g_option_table;
         }
         
-        virtual Error
+        Error
         SetOptionValue (uint32_t option_idx,
-                        const char *option_value)
+                        const char *option_value) override
         {
             Error error;
             
             const char short_option = (char) g_option_table[option_idx].short_option;
             
             switch (short_option)
             {
                 case 't':
                 {
                     bool success;
                     timeout = StringConvert::ToUInt32(option_value, 10, 10, &success);
                     if (!success)
                         error.SetErrorStringWithFormat("could not convert \"%s\" to a numeric value.", option_value);
                     break;
                 }
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
-        virtual void
-        OptionParsingStarting ()
+        void
+        OptionParsingStarting () override
         {
         }
         
         // Options table: Required for subclasses of Options.
         
         static OptionDefinition g_option_table[];
         uint32_t timeout;
     };
     
     CommandObjectPlatformShell (CommandInterpreter &interpreter) :
     CommandObjectRaw (interpreter, 
                       "platform shell",
                       "Run a shell command on the selected platform.",
                       "platform shell <shell-command>",
                       0),
     m_options(interpreter)
     {
     }
     
-    virtual
-    ~CommandObjectPlatformShell ()
+    ~CommandObjectPlatformShell () override
     {
     }
     
-    virtual
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
     
-    virtual bool
-    DoExecute (const char *raw_command_line, CommandReturnObject &result)
+    bool
+    DoExecute (const char *raw_command_line, CommandReturnObject &result) override
     {
         m_options.NotifyOptionParsingStarting();
         
         const char* expr = NULL;
 
         // Print out an usage syntax on an empty command line.
         if (raw_command_line[0] == '\0')
         {
public:
     CommandObjectParsed (interpreter,
                          "platform target-install",
                          "Install a target (bundle or executable file) to the remote end.",
                          "platform target-install <local-thing> <remote-sandbox>",
                          0)
     {
     }
     
-    virtual
-    ~CommandObjectPlatformInstall ()
+    ~CommandObjectPlatformInstall () override
     {
     }
     
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         if (args.GetArgumentCount() != 2)
         {
             result.AppendError("platform target-install takes two arguments");
             result.SetStatus(eReturnStatusFailed);
             return false;
         }
         // TODO: move the bulk of this code over to the platform itself

source/Commands/CommandObjectPlugin.cpp

CommandObjectParsed (interpreter,
         
         // There is only one variant this argument could be; put it into the argument entry.
         arg1.push_back (cmd_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
     }
     
-    ~CommandObjectPluginLoad ()
+    ~CommandObjectPluginLoad () override
     {
     }
     
     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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
         
         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
                                                              CommandCompletions::eDiskFileCompletion,
                                                              completion_str.c_str(),
                                                              match_start_point,
                                                              max_return_elements,
                                                              NULL,
                                                              word_complete,
                                                              matches);
         return matches.GetSize();
     }
 
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         size_t argc = command.GetArgumentCount();
         
         if (argc != 1)
         {
             result.AppendError ("'plugin load' requires one argument");
             result.SetStatus (eReturnStatusFailed);
             return false;

source/Commands/CommandObjectProcess.cpp

CommandObjectProcessLaunchOrAttach (CommandInterpreter &interpreter,
                                        const char *name,
                                        const char *help,
                                        const char *syntax,
                                        uint32_t flags,
                                        const char *new_process_action) :
         CommandObjectParsed (interpreter, name, help, syntax, flags),
         m_new_process_action (new_process_action) {}
     
-    virtual ~CommandObjectProcessLaunchOrAttach () {}
+    ~CommandObjectProcessLaunchOrAttach () override {}
 protected:
     bool
     StopProcessIfNecessary (Process *process, StateType &state, CommandReturnObject &result)
     {
         state = eStateInvalid;
         if (process)
         {
             state = process->GetState();
CommandObjectProcessLaunch (CommandInterpreter &interpreter) :
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (run_args_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
 
-    ~CommandObjectProcessLaunch ()
+    ~CommandObjectProcessLaunch () override
     {
     }
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
         
         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 
                                                              CommandCompletions::eDiskFileCompletion,
                                                              completion_str.c_str(),
                                                              match_start_point,
                                                              max_return_elements,
                                                              NULL,
                                                              word_complete,
                                                              matches);
         return matches.GetSize();
     }
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
-    virtual const char *GetRepeatCommand (Args &current_command_args, uint32_t index)
+    const char *
+    GetRepeatCommand (Args &current_command_args, uint32_t index) override
     {
         // No repeat for "process launch"...
         return "";
     }
 
 protected:
     bool
-    DoExecute (Args& launch_args, CommandReturnObject &result)
+    DoExecute (Args& launch_args, CommandReturnObject &result) override
     {
         Debugger &debugger = m_interpreter.GetDebugger();
         Target *target = debugger.GetSelectedTarget().get();
         // If our listener is NULL, users aren't allows to launch
         ModuleSP exe_module_sp = target->GetExecutableModule();
 
         if (exe_module_sp == NULL)
         {
public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options(interpreter)
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
             OptionParsingStarting ();
         }
 
-        ~CommandOptions ()
+        ~CommandOptions () override
         {
         }
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg)
+        SetOptionValue (uint32_t option_idx, const char *option_arg) override
         {
             Error error;
             const int short_option = m_getopt_table[option_idx].val;
             bool success = false;
             switch (short_option)
             {
                 case 'c':
                     attach_info.SetContinueOnceAttached(true);
public:
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             attach_info.Clear();
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
-        virtual bool
+        bool
         HandleOptionArgumentCompletion (Args &input,
                                         int cursor_index,
                                         int char_pos,
                                         OptionElementVector &opt_element_vector,
                                         int opt_element_index,
                                         int match_start_point,
                                         int max_return_elements,
                                         bool &word_complete,
-                                        StringList &matches)
+                                        StringList &matches) override
         {
             int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
             int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
     
             // We are only completing the name option for now...
             
             const OptionDefinition *opt_defs = GetDefinitions();
             if (opt_defs[opt_defs_index].short_option == 'n')
CommandObjectProcessAttach (CommandInterpreter &interpreter) :
                                             "Attach to a process.",
                                             "process attach <cmd-options>",
                                             0,
                                             "attach"),
         m_options (interpreter)
     {
     }
 
-    ~CommandObjectProcessAttach ()
+    ~CommandObjectProcessAttach () override
     {
     }
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
 protected:
     bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
 
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         // N.B. The attach should be synchronous.  It doesn't help much to get the prompt back between initiating the attach
         // and the target actually stopping.  So even if the interpreter is set to be asynchronous, we wait for the stop
         // ourselves here.
         
CommandObjectProcessContinue (CommandInterpreter &interpreter) :
                              eCommandTryTargetAPILock      |
                              eCommandProcessMustBeLaunched |
                              eCommandProcessMustBePaused   ),
         m_options(interpreter)
     {
     }
 
 
-    ~CommandObjectProcessContinue ()
+    ~CommandObjectProcessContinue () override
     {
     }
 
 protected:
 
     class CommandOptions : public Options
     {
     public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options(interpreter)
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
             OptionParsingStarting ();
         }
 
-        ~CommandOptions ()
+        ~CommandOptions () override
         {
         }
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg)
+        SetOptionValue (uint32_t option_idx, const char *option_arg) override
         {
             Error error;
             const int short_option = m_getopt_table[option_idx].val;
             bool success = false;
             switch (short_option)
             {
                 case 'i':
                     m_ignore = StringConvert::ToUInt32 (option_arg, 0, 0, &success);
                     if (!success)
                         error.SetErrorStringWithFormat ("invalid value for ignore option: \"%s\", should be a number.", option_arg);
                     break;
 
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_ignore = 0;
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
         // Options table: Required for subclasses of Options.
 
         static OptionDefinition g_option_table[];
 
         uint32_t m_ignore;
     };
     
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Process *process = m_exe_ctx.GetProcessPtr();
         bool synchronous_execution = m_interpreter.GetSynchronous ();
         StateType state = process->GetState();
         if (state == eStateStopped)
         {
             if (command.GetArgumentCount() != 0)
             {
DoExecute (Args& command, CommandReturnObject &result) override
             result.AppendErrorWithFormat ("Process cannot be continued from its current state (%s).\n",
                                          StateAsCString(state));
             result.SetStatus (eReturnStatusFailed);
         }
         return result.Succeeded();
     }
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
     
     CommandOptions m_options;
 
 };
 
public:
     public:
         
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter)
         {
             OptionParsingStarting ();
         }
 
-        ~CommandOptions ()
+        ~CommandOptions () override
         {
         }
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg)
+        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 's':
                     bool tmp_result;
public:
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_keep_stopped = eLazyBoolCalculate;
         }
 
         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.
         LazyBool m_keep_stopped;
     };
 
     CommandObjectProcessDetach (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "process detach",
                              "Detach from the current process being debugged.",
                              "process detach",
                              eCommandRequiresProcess      |
                              eCommandTryTargetAPILock     |
                              eCommandProcessMustBeLaunched),
         m_options(interpreter)
     {
     }
 
-    ~CommandObjectProcessDetach ()
+    ~CommandObjectProcessDetach () override
     {
     }
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
 
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Process *process = m_exe_ctx.GetProcessPtr();
         // FIXME: This will be a Command Option:
         bool keep_stopped;
         if (m_options.m_keep_stopped == eLazyBoolCalculate)
         {
             // Check the process default:
             if (process->GetDetachKeepsStopped())
public:
         
         CommandOptions (CommandInterpreter &interpreter) :
             Options(interpreter)
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
             OptionParsingStarting ();
         }
         
-        ~CommandOptions ()
+        ~CommandOptions () override
         {
         }
         
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg)
+        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 'p':   
                 plugin_name.assign (option_arg);    
                 break;
 
             default:
                 error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                 break;
             }
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             plugin_name.clear();
         }
         
         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.
         
         std::string plugin_name;        
     };
 
     CommandObjectProcessConnect (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "process connect",
                              "Connect to a remote debug service.",
                              "process connect <remote-url>",
                              0),
         m_options (interpreter)
     {
     }
     
-    ~CommandObjectProcessConnect ()
+    ~CommandObjectProcessConnect () override
     {
     }
 
     
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
     
 protected:
     bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         
         TargetSP target_sp (m_interpreter.GetDebugger().GetSelectedTarget());
         Error error;        
         Process *process = m_exe_ctx.GetProcessPtr();
         if (process)
         {
             if (process->IsAlive())
CommandObjectProcessPlugin (CommandInterpreter &interpreter) :
         CommandObjectProxy (interpreter,
                             "process plugin",
                             "Send a custom command to the current process plug-in.",
                             "process plugin <args>",
                             0)
     {
     }
     
-    ~CommandObjectProcessPlugin ()
+    ~CommandObjectProcessPlugin () override
     {
     }
 
-    virtual CommandObject *
-    GetProxyCommandObject()
+    CommandObject *
+    GetProxyCommandObject() override
     {
         Process *process = m_interpreter.GetExecutionContext().GetProcessPtr();
         if (process)
             return process->GetPluginCommandObject();
         return NULL;
     }
 };
 
CommandObjectProcessLoad (CommandInterpreter &interpreter) :
                              "process load <filename> [<filename> ...]",
                              eCommandRequiresProcess       |
                              eCommandTryTargetAPILock      |
                              eCommandProcessMustBeLaunched |
                              eCommandProcessMustBePaused   )
     {
     }
 
-    ~CommandObjectProcessLoad ()
+    ~CommandObjectProcessLoad () override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Process *process = m_exe_ctx.GetProcessPtr();
 
         const size_t argc = command.GetArgumentCount();
         
         for (uint32_t i=0; i<argc; ++i)
         {
             Error error;
CommandObjectProcessUnload (CommandInterpreter &interpreter) :
                              "process unload <index>",
                              eCommandRequiresProcess       |
                              eCommandTryTargetAPILock      |
                              eCommandProcessMustBeLaunched |
                              eCommandProcessMustBePaused   )
     {
     }
 
-    ~CommandObjectProcessUnload ()
+    ~CommandObjectProcessUnload () override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Process *process = m_exe_ctx.GetProcessPtr();
 
         const size_t argc = command.GetArgumentCount();
         
         for (uint32_t i=0; i<argc; ++i)
         {
             const char *image_token_cstr = command.GetArgumentAtIndex(i);
CommandObjectProcessSignal (CommandInterpreter &interpreter) :
         
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (signal_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    ~CommandObjectProcessSignal ()
+    ~CommandObjectProcessSignal () override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Process *process = m_exe_ctx.GetProcessPtr();
 
         if (command.GetArgumentCount() == 1)
         {
             int signo = LLDB_INVALID_SIGNAL_NUMBER;
             
             const char *signal_name = command.GetArgumentAtIndex(0);
CommandObjectProcessInterrupt (CommandInterpreter &interpreter) :
                              "Interrupt the current process being debugged.",
                              "process interrupt",
                              eCommandRequiresProcess      |
                              eCommandTryTargetAPILock     |
                              eCommandProcessMustBeLaunched)
     {
     }
 
-    ~CommandObjectProcessInterrupt ()
+    ~CommandObjectProcessInterrupt () override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command,
-               CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Process *process = m_exe_ctx.GetProcessPtr();
         if (process == NULL)
         {
             result.AppendError ("no process to halt");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
CommandObjectProcessKill (CommandInterpreter &interpreter) :
                              "Terminate the current process being debugged.",
                              "process kill",
                              eCommandRequiresProcess      |
                              eCommandTryTargetAPILock     |
                              eCommandProcessMustBeLaunched)
     {
     }
 
-    ~CommandObjectProcessKill ()
+    ~CommandObjectProcessKill () override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Process *process = m_exe_ctx.GetProcessPtr();
         if (process == NULL)
         {
             result.AppendError ("no process to kill");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
CommandObjectParsed (interpreter,
                          "Save the current process as a core file using an appropriate file type.",
                          "process save-core FILE",
                          eCommandRequiresProcess      |
                          eCommandTryTargetAPILock     |
                          eCommandProcessMustBeLaunched)
     {
     }
     
-    ~CommandObjectProcessSaveCore ()
+    ~CommandObjectProcessSaveCore () override
     {
     }
     
 protected:
     bool
     DoExecute (Args& command,
-               CommandReturnObject &result)
+               CommandReturnObject &result) override
     {
         ProcessSP process_sp = m_exe_ctx.GetProcessSP();
         if (process_sp)
         {
             if (command.GetArgumentCount() == 1)
             {
                 FileSpec output_file(command.GetArgumentAtIndex(0), false);
                 Error error = PluginManager::SaveCore(process_sp, output_file);
CommandObjectProcessStatus (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter, 
                              "process status",
                              "Show the current status and location of executing process.",
                              "process status",
                              eCommandRequiresProcess | eCommandTryTargetAPILock)
     {
     }
 
-    ~CommandObjectProcessStatus()
+    ~CommandObjectProcessStatus() override
     {
     }
 
 
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Stream &strm = result.GetOutputStream();
         result.SetStatus (eReturnStatusSuccessFinishNoResult);
         // No need to check "process" for validity as eCommandRequiresProcess ensures it is valid        
         Process *process = m_exe_ctx.GetProcessPtr();
         const bool only_threads_with_stop_reason = true;
         const uint32_t start_frame = 0;
         const uint32_t num_frames = 1;
public:
     public:
         
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter)
         {
             OptionParsingStarting ();
         }
 
-        ~CommandOptions ()
+        ~CommandOptions () override
         {
         }
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg)
+        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 's':
                     stop = option_arg;
                     break;
                 case 'n':
                     notify = option_arg;
                     break;
                 case 'p':
                     pass = option_arg;
                     break;
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             stop.clear();
             notify.clear();
             pass.clear();
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
         // Options table: Required for subclasses of Options.
 
         static OptionDefinition g_option_table[];
 
CommandObjectProcessHandle (CommandInterpreter &interpreter) :
         signal_arg.arg_type = eArgTypeUnixSignal;
         signal_arg.arg_repetition = eArgRepeatStar;
 
         arg.push_back (signal_arg);
         
         m_arguments.push_back (arg);
     }
 
-    ~CommandObjectProcessHandle ()
+    ~CommandObjectProcessHandle () override
     {
     }
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
     bool
     VerifyCommandOptionValue (const std::string &option, int &real_value)
     {
         bool okay = true;
PrintSignalInformation(Stream &str, Args &signal_args, int num_valid_signals, const UnixSignalsSP &signals_sp)
                 PrintSignal(str, signo, signals_sp->GetSignalAsCString(signo), signals_sp);
                 signo = signals_sp->GetNextSignalNumber(signo);
             }
         }
     }
 
 protected:
     bool
-    DoExecute (Args &signal_args, CommandReturnObject &result)
+    DoExecute (Args &signal_args, CommandReturnObject &result) override
     {
         TargetSP target_sp = m_interpreter.GetDebugger().GetSelectedTarget();
         
         if (!target_sp)
         {
             result.AppendError ("No current target;"
                                 " cannot handle signals until you have a valid target and process.\n");
             result.SetStatus (eReturnStatusFailed);

source/Commands/CommandObjectRegister.cpp

CommandObjectRegisterRead (CommandInterpreter &interpreter) :
 
         // Add the "--format"
         m_option_group.Append (&m_format_options, OptionGroupFormat::OPTION_GROUP_FORMAT | OptionGroupFormat::OPTION_GROUP_GDB_FMT, LLDB_OPT_SET_ALL);
         m_option_group.Append (&m_command_options);
         m_option_group.Finalize();
 
     }
 
-    virtual
-    ~CommandObjectRegisterRead ()
+    ~CommandObjectRegisterRead () override
     {
     }
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_option_group;
     }
 
     bool
     DumpRegister (const ExecutionContext &exe_ctx,
                   Stream &strm,
                   RegisterContext *reg_ctx,
DumpRegisterSet (const ExecutionContext &exe_ctx,
                 strm.Printf("%u registers were unavailable.\n", unavailable_count);
             }
             strm.EOL();
         }
         return available_count > 0;
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Stream &strm = result.GetOutputStream();
         RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext ();
 
         const RegisterInfo *reg_info = NULL;
         if (command.GetArgumentCount() == 0)
         {
             size_t set_idx;
public:
         CommandOptions () :
             OptionGroup(),
             set_indexes (OptionValue::ConvertTypeToMask (OptionValue::eTypeUInt64)),
             dump_all_sets (false, false), // Initial and default values are false
             alternate_name (false, false)
         {
         }
         
-        virtual
-        ~CommandOptions ()
+        ~CommandOptions () override
         {
         }
         
         
-        virtual uint32_t
-        GetNumDefinitions ();
+        uint32_t
+        GetNumDefinitions () override;
 
-        virtual const OptionDefinition*
-        GetDefinitions ()
+        const OptionDefinition*
+        GetDefinitions () override
         {
             return g_option_table;
         }
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter)
+        void
+        OptionParsingStarting (CommandInterpreter &interpreter) override
         {
             set_indexes.Clear();
             dump_all_sets.Clear();
             alternate_name.Clear();
         }
 
-        virtual Error
+        Error
         SetOptionValue (CommandInterpreter &interpreter,
                         uint32_t option_idx,
-                        const char *option_value)
+                        const char *option_value) override
         {
             Error error;
             const int short_option = g_option_table[option_idx].short_option;
             switch (short_option)
             {
                 case 's':
                     {
                         OptionValueSP value_sp (OptionValueUInt64::Create (option_value, error));
CommandObjectRegisterWrite (CommandInterpreter &interpreter) :
         // There is only one variant this argument could be; put it into the argument entry.
         arg2.push_back (value_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
         m_arguments.push_back (arg2);
     }
 
-    virtual
-    ~CommandObjectRegisterWrite ()
+    ~CommandObjectRegisterWrite () override
     {
     }
 
 protected:
-    virtual bool
-    DoExecute(Args& command, CommandReturnObject &result)
+    bool
+    DoExecute(Args& command, CommandReturnObject &result) override
     {
         DataExtractor reg_data;
         RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext ();
 
         if (command.GetArgumentCount() != 2)
         {
             result.AppendError ("register write takes exactly 2 arguments: <reg-name> <value>");
             result.SetStatus (eReturnStatusFailed);

source/Commands/CommandObjectSettings.cpp

 just want to add, remove or update individual values (or add something to \
 the end), use one of the other settings sub-commands: append, replace, \
 insert-before or insert-after."
         );
 
     }
 
 
-    virtual
-    ~CommandObjectSettingsSet () {}
+    ~CommandObjectSettingsSet () override {}
 
     // Overrides base class's behavior where WantsCompletion = !WantsRawCommandString.
-    virtual bool
-    WantsCompletion() { return true; }
+    bool
+    WantsCompletion() override { return true; }
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
     class CommandOptions : public Options
     {
     public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             m_global (false)
         {
         }
 
-        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 'g':
                     m_global = true;
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized options '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_global = 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_global;
     };
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         const size_t argc = input.GetArgumentCount();
         const char *arg = NULL;
         int setting_var_idx;
         for (setting_var_idx = 1; setting_var_idx < static_cast<int>(argc);
              ++setting_var_idx)
HandleArgumentCompletion (Args &input,
                     }
                 }
             }
         }
         return matches.GetSize();
     }
     
 protected:
-    virtual bool
-    DoExecute (const char *command, CommandReturnObject &result)
+    bool
+    DoExecute (const char *command, CommandReturnObject &result) override
     {
         Args cmd_args(command);
 
         // Process possible options.
         if (!ParseOptions (cmd_args, result))
             return false;
 
         const size_t argc = cmd_args.GetArgumentCount ();
CommandObjectSettingsShow (CommandInterpreter &interpreter) :
 
         // There is only one variant this argument could be; put it into the argument entry.
         arg1.push_back (var_name_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
     }
 
-    virtual
-    ~CommandObjectSettingsShow () {}
+    ~CommandObjectSettingsShow () override {}
 
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
                                                              CommandCompletions::eSettingsNameCompletion,
                                                              completion_str.c_str(),
                                                              match_start_point,
                                                              max_return_elements,
                                                              NULL,
                                                              word_complete,
                                                              matches);
         return matches.GetSize();
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         result.SetStatus (eReturnStatusSuccessFinishResult);
 
         const size_t argc = args.GetArgumentCount ();
         if (argc > 0)
         {
             for (size_t i=0; i<argc; ++i)
             {
CommandObjectSettingsList (CommandInterpreter &interpreter) :
 
         arg.push_back (var_name_arg);
         arg.push_back (prefix_name_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    virtual
-    ~CommandObjectSettingsList () {}
+    ~CommandObjectSettingsList () override {}
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
                                                              CommandCompletions::eSettingsNameCompletion,
                                                              completion_str.c_str(),
                                                              match_start_point,
                                                              max_return_elements,
                                                              NULL,
                                                              word_complete,
                                                              matches);
         return matches.GetSize();
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         result.SetStatus (eReturnStatusSuccessFinishResult);
 
         const bool will_modify = false;
         const size_t argc = args.GetArgumentCount ();
         if (argc > 0)
         {
             const bool dump_qualified_name = true;
CommandObjectSettingsRemove (CommandInterpreter &interpreter) :
         arg2.push_back (index_arg);
         arg2.push_back (key_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
         m_arguments.push_back (arg2);
     }
 
-    virtual
-    ~CommandObjectSettingsRemove () {}
+    ~CommandObjectSettingsRemove () override {}
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         // Attempting to complete variable name
         if (cursor_index < 2)
             CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
                                                                  CommandCompletions::eSettingsNameCompletion,
                                                                  completion_str.c_str(),
                                                                  match_start_point,
                                                                  max_return_elements,
                                                                  NULL,
                                                                  word_complete,
                                                                  matches);
 
         return matches.GetSize();
     }
 
 protected:
-    virtual bool
-    DoExecute (const char *command, CommandReturnObject &result)
+    bool
+    DoExecute (const char *command, CommandReturnObject &result) override
     {
         result.SetStatus (eReturnStatusSuccessFinishNoResult);
      
         Args cmd_args(command);
         
         // Process possible options.
         if (!ParseOptions (cmd_args, result))
             return false;
CommandObjectSettingsReplace (CommandInterpreter &interpreter) :
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
         m_arguments.push_back (arg2);
         m_arguments.push_back (arg3);
     }
 
 
-    virtual
-    ~CommandObjectSettingsReplace () {}
+    ~CommandObjectSettingsReplace () override {}
 
     // Overrides base class's behavior where WantsCompletion = !WantsRawCommandString.
-    virtual bool
-    WantsCompletion() { return true; }
+    bool
+    WantsCompletion() override { return true; }
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         // Attempting to complete variable name
         if (cursor_index < 2)
             CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
                                                                  CommandCompletions::eSettingsNameCompletion,
                                                                  completion_str.c_str(),
                                                                  match_start_point,
                                                                  max_return_elements,
                                                                  NULL,
                                                                  word_complete,
                                                                  matches);
 
         return matches.GetSize();
     }
 
 protected:
-    virtual bool
-    DoExecute (const char *command, CommandReturnObject &result)
+    bool
+    DoExecute (const char *command, CommandReturnObject &result) override
     {
         result.SetStatus (eReturnStatusSuccessFinishNoResult);
 
         Args cmd_args(command);
         const char *var_name = cmd_args.GetArgumentAtIndex (0);
         if ((var_name == NULL) || (var_name[0] == '\0'))
         {
             result.AppendError ("'settings replace' command requires a valid variable name; No value supplied");
CommandObjectSettingsInsertBefore (CommandInterpreter &interpreter) :
         arg3.push_back (value_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
         m_arguments.push_back (arg2);
         m_arguments.push_back (arg3);
     }
 
-    virtual
-    ~CommandObjectSettingsInsertBefore () {}
+    ~CommandObjectSettingsInsertBefore () override {}
 
     // Overrides base class's behavior where WantsCompletion = !WantsRawCommandString.
-    virtual bool
-    WantsCompletion() { return true; }
+    bool
+    WantsCompletion() override { return true; }
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         // Attempting to complete variable name
         if (cursor_index < 2)
             CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
                                                                  CommandCompletions::eSettingsNameCompletion,
                                                                  completion_str.c_str(),
                                                                  match_start_point,
                                                                  max_return_elements,
                                                                  NULL,
                                                                  word_complete,
                                                                  matches);
 
         return matches.GetSize();
     }
 
 protected:
-    virtual bool
-    DoExecute (const char *command, CommandReturnObject &result)
+    bool
+    DoExecute (const char *command, CommandReturnObject &result) override
     {
         result.SetStatus (eReturnStatusSuccessFinishNoResult);
 
         Args cmd_args(command);
         const size_t argc = cmd_args.GetArgumentCount ();
 
         if (argc < 3)
         {
CommandObjectSettingsInsertAfter (CommandInterpreter &interpreter) :
         arg3.push_back (value_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
         m_arguments.push_back (arg2);
         m_arguments.push_back (arg3);
     }
 
-    virtual
-    ~CommandObjectSettingsInsertAfter () {}
+    ~CommandObjectSettingsInsertAfter () override {}
 
     // Overrides base class's behavior where WantsCompletion = !WantsRawCommandString.
-    virtual bool
-    WantsCompletion() { return true; }
+    bool
+    WantsCompletion() override { return true; }
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         // Attempting to complete variable name
         if (cursor_index < 2)
             CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
                                                                  CommandCompletions::eSettingsNameCompletion,
                                                                  completion_str.c_str(),
                                                                  match_start_point,
                                                                  max_return_elements,
                                                                  NULL,
                                                                  word_complete,
                                                                  matches);
 
         return matches.GetSize();
     }
     
 protected:
-    virtual bool
-    DoExecute (const char *command, CommandReturnObject &result)
+    bool
+    DoExecute (const char *command, CommandReturnObject &result) override
     {
         result.SetStatus (eReturnStatusSuccessFinishNoResult);
 
         Args cmd_args(command);
         const size_t argc = cmd_args.GetArgumentCount ();
 
         if (argc < 3)
         {
CommandObjectSettingsAppend (CommandInterpreter &interpreter) :
         // There is only one variant this argument could be; put it into the argument entry.
         arg2.push_back (value_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
         m_arguments.push_back (arg2);
     }
 
-    virtual
-    ~CommandObjectSettingsAppend () {}
+    ~CommandObjectSettingsAppend () override {}
 
     // Overrides base class's behavior where WantsCompletion = !WantsRawCommandString.
-    virtual bool
-    WantsCompletion() { return true; }
+    bool
+    WantsCompletion() override { return true; }
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         // Attempting to complete variable name
         if (cursor_index < 2)
             CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
                                                                  CommandCompletions::eSettingsNameCompletion,
                                                                  completion_str.c_str(),
                                                                  match_start_point,
                                                                  max_return_elements,
                                                                  NULL,
                                                                  word_complete,
                                                                  matches);
 
         return matches.GetSize();
     }
 
 protected:
-    virtual bool
-    DoExecute (const char *command, CommandReturnObject &result)
+    bool
+    DoExecute (const char *command, CommandReturnObject &result) override
     {
         result.SetStatus (eReturnStatusSuccessFinishNoResult);
         Args cmd_args(command);
         const size_t argc = cmd_args.GetArgumentCount ();
 
         if (argc < 2)
         {
             result.AppendError ("'settings append' takes more arguments");
CommandObjectSettingsClear (CommandInterpreter &interpreter) :
 
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (var_name_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    virtual
-    ~CommandObjectSettingsClear () {}
+    ~CommandObjectSettingsClear () override {}
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         // Attempting to complete variable name
         if (cursor_index < 2)
             CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
                                                                  CommandCompletions::eSettingsNameCompletion,
                                                                  completion_str.c_str(),
                                                                  match_start_point,
                                                                  max_return_elements,
                                                                  NULL,
                                                                  word_complete,
                                                                  matches);
 
         return matches.GetSize();
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         result.SetStatus (eReturnStatusSuccessFinishNoResult);
         const size_t argc = command.GetArgumentCount ();
 
         if (argc != 1)
         {
             result.AppendError ("'settings clear' takes exactly one argument");
             result.SetStatus (eReturnStatusFailed);

source/Commands/CommandObjectSource.cpp

class CommandObjectSourceInfo : public CommandObjectParsed
     class CommandOptions : public Options
     {
     public:
         CommandOptions (CommandInterpreter &interpreter) :
             Options(interpreter)
         {
         }
 
-        ~CommandOptions ()
+        ~CommandOptions () override
         {
         }
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg)
+        SetOptionValue (uint32_t option_idx, const char *option_arg) override
         {
             Error error;
             const int short_option = g_option_table[option_idx].short_option;
             switch (short_option)
             {
             case 'l':
                 start_line = StringConvert::ToUInt32 (option_arg, 0);
                 if (start_line == 0)
                     error.SetErrorStringWithFormat("invalid line number: '%s'", option_arg);
                 break;
 
              case 'f':
                 file_name = option_arg;
                 break;
 
            default:
                 error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
                 break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             file_spec.Clear();
             file_name.clear();
             start_line = 0;
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
         static OptionDefinition g_option_table[];
 
         // Instance variables to hold the values for command options.
         FileSpec file_spec;
         std::string file_name;
         uint32_t start_line;
         
     };
  
 public:   
     CommandObjectSourceInfo(CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "source info",
                              "Display information about the source lines from the current executable's debug info.",
                              "source info [<cmd-options>]"),
         m_options (interpreter)
     {
     }
 
-    ~CommandObjectSourceInfo ()
+    ~CommandObjectSourceInfo () override
     {
     }
 
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         result.AppendError ("Not yet implemented");
         result.SetStatus (eReturnStatusFailed);
         return false;
     }
 
     CommandOptions m_options;
 };
class CommandObjectSourceList : public CommandObjectParsed
     class CommandOptions : public Options
     {
     public:
         CommandOptions (CommandInterpreter &interpreter) :
             Options(interpreter)
         {
         }
 
-        ~CommandOptions ()
+        ~CommandOptions () override
         {
         }
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg)
+        SetOptionValue (uint32_t option_idx, const char *option_arg) override
         {
             Error error;
             const int short_option = g_option_table[option_idx].short_option;
             switch (short_option)
             {
             case 'l':
                 start_line = StringConvert::ToUInt32 (option_arg, 0);
                 if (start_line == 0)
public:
                 error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
                 break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             file_spec.Clear();
             file_name.clear();
             symbol_name.clear();
             address = LLDB_INVALID_ADDRESS;
             start_line = 0;
             num_lines = 0;
             show_bp_locs = false;
             reverse = false;
             modules.clear();
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
         static OptionDefinition g_option_table[];
 
         // Instance variables to hold the values for command options.
         FileSpec file_spec;
         std::string file_name;
CommandObjectSourceList(CommandInterpreter &interpreter) :
                              "source list",
                              "Display source code (as specified) based on the current executable's debug info.",
                              NULL,
                              eCommandRequiresTarget), 
         m_options (interpreter)
     {
     }
 
-    ~CommandObjectSourceList ()
+    ~CommandObjectSourceList () override
     {
     }
 
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
-    virtual const char *
-    GetRepeatCommand (Args &current_command_args, uint32_t index)
+    const char *
+    GetRepeatCommand (Args &current_command_args, uint32_t index) override
     {
         // This is kind of gross, but the command hasn't been parsed yet so we can't look at the option
         // values for this invocation...  I have to scan the arguments directly.
         size_t num_args = current_command_args.GetArgumentCount();
         bool is_reverse = false;
         for (size_t i = 0 ; i < num_args; i++)
         {
             const char *arg = current_command_args.GetArgumentAtIndex(i);
size_t FindMatchingFunctionSymbols (Target *target, const ConstString &name, SymbolContextList& sc_list)
         else
         {
             num_matches = target->GetImages().FindFunctionSymbols (name, eFunctionNameTypeAuto, sc_list);
         }
         return num_matches;
     }
 
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
 
         if (argc != 0)
         {
             result.AppendErrorWithFormat("'%s' takes no arguments, only flags.\n", GetCommandName());
             result.SetStatus (eReturnStatusFailed);
             return false;

source/Commands/CommandObjectTarget.cpp

CommandObjectTargetCreate(CommandInterpreter &interpreter) :
         m_option_group.Append (&m_core_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_platform_path, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_symbol_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_remote_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_add_dependents, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Finalize();
     }
 
-    ~CommandObjectTargetCreate ()
+    ~CommandObjectTargetCreate () override
     {
     }
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_option_group;
     }
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
 
         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 
                                                              CommandCompletions::eDiskFileCompletion,
                                                              completion_str.c_str(),
                                                              match_start_point,
                                                              max_return_elements,
                                                              NULL,
                                                              word_complete,
                                                              matches);
         return matches.GetSize();
     }
 
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         FileSpec core_file (m_core_file.GetOptionValue().GetCurrentValue());
         FileSpec remote_file (m_remote_file.GetOptionValue().GetCurrentValue());
 
         if (core_file)
         {
             if (!core_file.Exists())
CommandObjectTargetList (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "target list",
                              "List all current targets in the current debug session.",
                              NULL,
                              0)
     {
     }
 
-    virtual
-    ~CommandObjectTargetList ()
+    ~CommandObjectTargetList () override
     {
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         if (args.GetArgumentCount() == 0)
         {
             Stream &strm = result.GetOutputStream();
 
             bool show_stopped_process_status = false;
             if (DumpTargetList (m_interpreter.GetDebugger().GetTargetList(), show_stopped_process_status, strm) == 0)
             {
CommandObjectTargetSelect (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "target select",
                              "Select a target as the current target by target index.",
                              NULL,
                              0)
     {
     }
 
-    virtual
-    ~CommandObjectTargetSelect ()
+    ~CommandObjectTargetSelect () override
     {
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         if (args.GetArgumentCount() == 1)
         {
             bool success = false;
             const char *target_idx_arg = args.GetArgumentAtIndex(0);
             uint32_t target_idx = StringConvert::ToUInt32 (target_idx_arg, UINT32_MAX, 0, &success);
             if (success)
             {
CommandObjectTargetDelete (CommandInterpreter &interpreter) :
             "cause them to be reparsed again the next time the target is run",
             false, true)
     {
         m_option_group.Append(&m_all_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append(&m_cleanup_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Finalize();
     }
 
-    virtual
-    ~CommandObjectTargetDelete ()
+    ~CommandObjectTargetDelete () override
     {
     }
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_option_group;
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         const size_t argc = args.GetArgumentCount();
         std::vector<TargetSP> delete_target_list;
         TargetList &target_list = m_interpreter.GetDebugger().GetTargetList();
         TargetSP target_sp;
 
         if (m_all_option.GetOptionValue())
         {
CommandObjectTargetVariable (CommandInterpreter &interpreter) :
         m_option_group.Append (&m_varobj_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_option_variable, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_option_format, OptionGroupFormat::OPTION_GROUP_FORMAT | OptionGroupFormat::OPTION_GROUP_GDB_FMT, LLDB_OPT_SET_1);
         m_option_group.Append (&m_option_compile_units, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);   
         m_option_group.Append (&m_option_shared_libraries, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);   
         m_option_group.Finalize();
     }
 
-    virtual
-    ~CommandObjectTargetVariable ()
+    ~CommandObjectTargetVariable () override
     {
     }
 
     void
     DumpValueObject (Stream &s, VariableSP &var_sp, ValueObjectSP &valobj_sp, const char *root_name)
     {
         DumpValueObjectOptions options(m_varobj_options.GetAsDumpOptions());
 
static size_t GetVariableCallback (void *baton,
                                                             true, 
                                                             UINT32_MAX, 
                                                             variable_list);
         }
         return 0;
     }
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_option_group;
     }
 
 protected:
     void
     DumpGlobalVariableList(const ExecutionContext &exe_ctx, const SymbolContext &sc, const VariableList &variable_list, Stream &s)
     {
DumpGlobalVariableList(const ExecutionContext &exe_ctx, const SymbolContext &sc, const VariableList &variable_list, Stream &s)
 
                     if (valobj_sp)
                         DumpValueObject (s, var_sp, valobj_sp, var_sp->GetName().GetCString());
                 }
             }
         }
 
     }
-    virtual bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         Target *target = m_exe_ctx.GetTargetPtr();
         const size_t argc = args.GetArgumentCount();
         Stream &s = result.GetOutputStream();
 
         if (argc > 0)
         {
 
CommandObjectTargetModulesSearchPathsAdd (CommandInterpreter &interpreter) :
         // arguments.  Push them both into the first argument position for m_arguments...
 
         arg.push_back (old_prefix_arg);
         arg.push_back (new_prefix_arg);
 
         m_arguments.push_back (arg);
     }
 
-    ~CommandObjectTargetModulesSearchPathsAdd ()
+    ~CommandObjectTargetModulesSearchPathsAdd () override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (target)
         {
             const size_t argc = command.GetArgumentCount();
             if (argc & 1)
             {
                 result.AppendError ("add requires an even number of arguments\n");
public:
     CommandObjectTargetModulesSearchPathsClear (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "target modules search-paths clear",
                              "Clear all current image search path substitution pairs from the current target.",
                              "target modules search-paths clear")
     {
     }
 
-    ~CommandObjectTargetModulesSearchPathsClear ()
+    ~CommandObjectTargetModulesSearchPathsClear () override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (target)
         {
             bool notify = true;
             target->GetImageSearchPathList().Clear(notify);
             result.SetStatus (eReturnStatusSuccessFinishNoResult);
         }
CommandObjectTargetModulesSearchPathsInsert (CommandInterpreter &interpreter) :
         arg2.push_back (old_prefix_arg);
         arg2.push_back (new_prefix_arg);
 
         // Add arguments to m_arguments.
         m_arguments.push_back (arg1);
         m_arguments.push_back (arg2);
     }
 
-    ~CommandObjectTargetModulesSearchPathsInsert ()
+    ~CommandObjectTargetModulesSearchPathsInsert () override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (target)
         {
             size_t argc = command.GetArgumentCount();
             // check for at least 3 arguments and an odd nubmer of parameters
             if (argc >= 3 && argc & 1)
             {
public:
     CommandObjectTargetModulesSearchPathsList (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "target modules search-paths list",
                              "List all current image search path substitution pairs in the current target.",
                              "target modules search-paths list")
     {
     }
 
-    ~CommandObjectTargetModulesSearchPathsList ()
+    ~CommandObjectTargetModulesSearchPathsList () override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (target)
         {
             if (command.GetArgumentCount() != 0)
             {
                 result.AppendError ("list takes no arguments\n");
                 result.SetStatus (eReturnStatusFailed);
CommandObjectTargetModulesSearchPathsQuery (CommandInterpreter &interpreter) :
 
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (path_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    ~CommandObjectTargetModulesSearchPathsQuery ()
+    ~CommandObjectTargetModulesSearchPathsQuery () override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (target)
         {
             if (command.GetArgumentCount() != 1)
             {
                 result.AppendError ("query requires one argument\n");
                 result.SetStatus (eReturnStatusFailed);
CommandObjectTargetModulesModuleAutoComplete (CommandInterpreter &interpreter,
 
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (file_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    virtual
-    ~CommandObjectTargetModulesModuleAutoComplete ()
+    ~CommandObjectTargetModulesModuleAutoComplete () override
     {
     }
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         // Arguments are the standard module completer.
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
 
         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
                                                              CommandCompletions::eModuleCompletion,
                                                              completion_str.c_str(),
CommandObjectTargetModulesSourceFileAutoComplete (CommandInterpreter &interpreter,
 
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (source_file_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    virtual
-    ~CommandObjectTargetModulesSourceFileAutoComplete ()
+    ~CommandObjectTargetModulesSourceFileAutoComplete () override
     {
     }
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         // Arguments are the standard source file completer.
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
 
         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 
                                                              CommandCompletions::eSourceFileCompletion,
                                                              completion_str.c_str(),
public:
     CommandObjectTargetModulesModuleAutoComplete (interpreter,
                                       "target modules dump symtab",
                                       "Dump the symbol table from one or more target modules.",
                                       NULL),
     m_options (interpreter)
     {
     }
 
-    virtual
-    ~CommandObjectTargetModulesDumpSymtab ()
+    ~CommandObjectTargetModulesDumpSymtab () override
     {
     }
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
         CommandOptions (CommandInterpreter &interpreter) :
         Options(interpreter),
         m_sort_order (eSortOrderNone)
         {
         }
 
-        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 's':
                     m_sort_order = (SortOrder) Args::StringToOptionEnum (option_arg, 
                                                                          g_option_table[option_idx].enum_values, 
                                                                          eSortOrderNone,
                                                                          error);
                     break;
 
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
 
             }
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_sort_order = eSortOrderNone;
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
         // Options table: Required for subclasses of Options.
         static OptionDefinition g_option_table[];
 
         SortOrder m_sort_order;
     };
 
 protected:
-    virtual bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (target == NULL)
         {
             result.AppendError ("invalid target, create a debug target using the 'target create' command");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
public:
     CommandObjectTargetModulesModuleAutoComplete (interpreter,
                                       "target modules dump sections",
                                       "Dump the sections from one or more target modules.",
                                       //"target modules dump sections [<file1> ...]")
                                       NULL)
     {
     }
 
-    virtual
-    ~CommandObjectTargetModulesDumpSections ()
+    ~CommandObjectTargetModulesDumpSections () override
     {
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (target == NULL)
         {
             result.AppendError ("invalid target, create a debug target using the 'target create' command");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
public:
     CommandObjectTargetModulesModuleAutoComplete (interpreter,
                                       "target modules dump symfile",
                                       "Dump the debug symbol file for one or more target modules.",
                                       //"target modules dump symfile [<file1> ...]")
                                       NULL)
     {
     }
 
-    virtual
-    ~CommandObjectTargetModulesDumpSymfile ()
+    ~CommandObjectTargetModulesDumpSymfile () override
     {
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (target == NULL)
         {
             result.AppendError ("invalid target, create a debug target using the 'target create' command");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
public:
     CommandObjectTargetModulesSourceFileAutoComplete (interpreter,
                                                       "target modules dump line-table",
                                                       "Dump the line table for one or more compilation units.",
                                                       NULL,
                                                       eCommandRequiresTarget)
     {
     }
 
-    virtual
-    ~CommandObjectTargetModulesDumpLineTable ()
+    ~CommandObjectTargetModulesDumpLineTable () override
     {
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result)
     {
         Target *target = m_exe_ctx.GetTargetPtr();
         uint32_t total_num_dumped = 0;
 
         uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
         result.GetOutputStream().SetAddressByteSize(addr_byte_size);
         result.GetErrorStream().SetAddressByteSize(addr_byte_size);
 
CommandObjectMultiword (interpreter,
                             "target modules dump [symtab|sections|symfile|line-table] [<file1> <file2> ...]")
     {
         LoadSubCommand ("symtab",      CommandObjectSP (new CommandObjectTargetModulesDumpSymtab (interpreter)));
         LoadSubCommand ("sections",    CommandObjectSP (new CommandObjectTargetModulesDumpSections (interpreter)));
         LoadSubCommand ("symfile",     CommandObjectSP (new CommandObjectTargetModulesDumpSymfile (interpreter)));
         LoadSubCommand ("line-table",  CommandObjectSP (new CommandObjectTargetModulesDumpLineTable (interpreter)));
     }
 
-    virtual
-    ~CommandObjectTargetModulesDump()
+    ~CommandObjectTargetModulesDump() override
     {
     }
 };
 
 class CommandObjectTargetModulesAdd : public CommandObjectParsed
 {
 public:
     CommandObjectTargetModulesAdd (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "target modules add",
                              "Add a new module to the current target's modules.",
                              "target modules add [<module>]"),
         m_option_group (interpreter),
         m_symbol_file (LLDB_OPT_SET_1, false, "symfile", 's', 0, eArgTypeFilename, "Fullpath to a stand alone debug symbols file for when debug symbols are not in the executable.")
     {
         m_option_group.Append (&m_uuid_option_group, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_symbol_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Finalize();
     }
 
-    virtual
-    ~CommandObjectTargetModulesAdd ()
+    ~CommandObjectTargetModulesAdd () override
     {
     }
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_option_group;
     }
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
 
         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 
                                                              CommandCompletions::eDiskFileCompletion,
                                                              completion_str.c_str(),
                                                              match_start_point,
                                                              max_return_elements,
                                                              NULL,
                                                              word_complete,
                                                              matches);
         return matches.GetSize();
     }
 
 protected:
     OptionGroupOptions m_option_group;
     OptionGroupUUID m_uuid_option_group;
     OptionGroupFile m_symbol_file;
 
-    virtual bool
-    DoExecute (Args& args,
-             CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (target == NULL)
         {
             result.AppendError ("invalid target, create a debug target using the 'target create' command");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
CommandObjectTargetModulesLoad (CommandInterpreter &interpreter) :
         m_slide_option(LLDB_OPT_SET_1, false, "slide", 's', 0, eArgTypeOffset, "Set the load address for all sections to be the virtual address in the file plus the offset.", 0)
     {
         m_option_group.Append (&m_uuid_option_group, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_file_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_slide_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 
         m_option_group.Finalize();
     }
 
-    virtual
-    ~CommandObjectTargetModulesLoad ()
+    ~CommandObjectTargetModulesLoad () override
     {
     }
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_option_group;
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& args,
-             CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (target == NULL)
         {
             result.AppendError ("invalid target, create a debug target using the 'target create' command");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
public:
         CommandOptions (CommandInterpreter &interpreter) :
             Options(interpreter),
             m_format_array(),
             m_use_global_module_list (false),
             m_module_addr (LLDB_INVALID_ADDRESS)
         {
         }
 
-        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;
             if (short_option == 'g')
             {
                 m_use_global_module_list = true;
             }
             else if (short_option == 'a')
             {
                 ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
                 m_module_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
             }
             else
             {
                 unsigned long width = 0;
                 if (option_arg)
                     width = strtoul (option_arg, NULL, 0);
                 m_format_array.push_back(std::make_pair(short_option, width));
             }
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_format_array.clear();
             m_use_global_module_list = false;
             m_module_addr = LLDB_INVALID_ADDRESS;
         }
 
         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.
         typedef std::vector< std::pair<char, uint32_t> > FormatWidthCollection;
         FormatWidthCollection m_format_array;
         bool m_use_global_module_list;
         lldb::addr_t m_module_addr;
     };
 
     CommandObjectTargetModulesList (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "target modules list",
                              "List current executable and dependent shared library images.",
                              "target modules list [<cmd-options>]"),
         m_options (interpreter)
     {
     }
 
-    virtual
-    ~CommandObjectTargetModulesList ()
+    ~CommandObjectTargetModulesList () override
     {
     }
 
-    virtual
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         const bool use_global_module_list = m_options.m_use_global_module_list;
         // Define a local module list here to ensure it lives longer than any "locker"
         // object which might lock its contents below (through the "module_list_ptr"
         // variable).
         ModuleList module_list;
         if (target == NULL && use_global_module_list == false)
public:
         CommandOptions (CommandInterpreter &interpreter) :
             Options(interpreter),
             m_type(eLookupTypeInvalid),
             m_str(),
             m_addr(LLDB_INVALID_ADDRESS)
         {
         }
 
-        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':
public:
                     error.SetErrorStringWithFormat ("unrecognized option %c.", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_type = eLookupTypeInvalid;
             m_str.clear();
             m_addr = LLDB_INVALID_ADDRESS;
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
         // Options table: Required for subclasses of Options.
 
         static OptionDefinition g_option_table[];
 
CommandObjectTargetModulesShowUnwind (CommandInterpreter &interpreter) :
                              eCommandRequiresTarget        |
                              eCommandRequiresProcess       |
                              eCommandProcessMustBeLaunched |
                              eCommandProcessMustBePaused   ),
         m_options (interpreter)
     {
     }
 
-    virtual
-    ~CommandObjectTargetModulesShowUnwind ()
+    ~CommandObjectTargetModulesShowUnwind () override
     {
     }
 
-    virtual
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
 protected:
     bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_exe_ctx.GetTargetPtr();
         Process *process = m_exe_ctx.GetProcessPtr();
         ABI *abi = NULL;
         if (process)
           abi = process->GetABI().get();
 
         if (process == NULL)
public:
     {
     public:
         CommandOptions (CommandInterpreter &interpreter) :
         Options(interpreter)
         {
             OptionParsingStarting();
         }
 
-        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':
public:
                     m_use_regex = true;
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_type = eLookupTypeInvalid;
             m_str.clear();
             m_file.Clear();
             m_addr = LLDB_INVALID_ADDRESS;
             m_offset = 0;
             m_line_number = 0;
             m_use_regex = false;
             m_include_inlines = true;
             m_verbose = false;
             m_print_all = false;
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
         // Options table: Required for subclasses of Options.
 
         static OptionDefinition g_option_table[];
         int             m_type;         // Should be a eLookupTypeXXX enum after parsing options
CommandObjectTargetModulesLookup (CommandInterpreter &interpreter) :
 
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (file_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    virtual
-    ~CommandObjectTargetModulesLookup ()
+    ~CommandObjectTargetModulesLookup () override
     {
     }
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
     bool
     LookupHere (CommandInterpreter &interpreter, CommandReturnObject &result, bool &syntax_error)
     {
         switch (m_options.m_type)
LookupInModule (CommandInterpreter &interpreter, Module *module, CommandReturnObject &result, bool &syntax_error)
                 break;
         }
 
         result.SetStatus (eReturnStatusFailed);
         return false;
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (target == NULL)
         {
             result.AppendError ("invalid target, create a debug target using the 'target create' command");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
public:
     {
         LoadSubCommand ("add",     CommandObjectSP (new CommandObjectTargetModulesSearchPathsAdd (interpreter)));
         LoadSubCommand ("clear",   CommandObjectSP (new CommandObjectTargetModulesSearchPathsClear (interpreter)));
         LoadSubCommand ("insert",  CommandObjectSP (new CommandObjectTargetModulesSearchPathsInsert (interpreter)));
         LoadSubCommand ("list",    CommandObjectSP (new CommandObjectTargetModulesSearchPathsList (interpreter)));
         LoadSubCommand ("query",   CommandObjectSP (new CommandObjectTargetModulesSearchPathsQuery (interpreter)));
     }
 
-    ~CommandObjectTargetModulesImageSearchPaths()
+    ~CommandObjectTargetModulesImageSearchPaths() override
     {
     }
 };
 
 
 
 #pragma mark CommandObjectTargetModules
 
CommandObjectTargetModules(CommandInterpreter &interpreter) :
         LoadSubCommand ("load",         CommandObjectSP (new CommandObjectTargetModulesLoad (interpreter)));
         LoadSubCommand ("dump",         CommandObjectSP (new CommandObjectTargetModulesDump (interpreter)));
         LoadSubCommand ("list",         CommandObjectSP (new CommandObjectTargetModulesList (interpreter)));
         LoadSubCommand ("lookup",       CommandObjectSP (new CommandObjectTargetModulesLookup (interpreter)));
         LoadSubCommand ("search-paths", CommandObjectSP (new CommandObjectTargetModulesImageSearchPaths (interpreter)));
         LoadSubCommand ("show-unwind",  CommandObjectSP (new CommandObjectTargetModulesShowUnwind (interpreter)));
 
     }
-    virtual
-    ~CommandObjectTargetModules()
+
+    ~CommandObjectTargetModules() override
     {
     }
 
 private:
     //------------------------------------------------------------------
     // For CommandObjectTargetModules only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (CommandObjectTargetModules);
public:
 
     {
         m_option_group.Append (&m_uuid_option_group, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_file_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_current_frame_option, LLDB_OPT_SET_2, LLDB_OPT_SET_2);
         m_option_group.Finalize();
     }
 
-    virtual
-    ~CommandObjectTargetSymbolsAdd ()
+    ~CommandObjectTargetSymbolsAdd () override
     {
     }
 
-    virtual int
+    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)
+                              StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
 
         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 
                                                              CommandCompletions::eDiskFileCompletion,
                                                              completion_str.c_str(),
                                                              match_start_point,
                                                              max_return_elements,
                                                              NULL,
                                                              word_complete,
                                                              matches);
         return matches.GetSize();
     }
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_option_group;
     }
 
 protected:
     bool
     AddModuleSymbols (Target *target,
                       ModuleSpec &module_spec,
AddModuleSymbols (Target *target,
         else
         {
             result.AppendError ("one or more executable image paths must be specified");
         }
         result.SetStatus (eReturnStatusFailed);
         return false;
     }
 
-    virtual bool
-    DoExecute (Args& args,
-             CommandReturnObject &result)
+    bool
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         Target *target = m_exe_ctx.GetTargetPtr();
         result.SetStatus (eReturnStatusFailed);
         bool flush = false;
         ModuleSpec module_spec;
         const bool uuid_option_set = m_uuid_option_group.GetOptionValue().OptionWasSet();
         const bool file_option_set = m_file_option.GetOptionValue().OptionWasSet();
         const bool frame_option_set = m_current_frame_option.GetOptionValue().OptionWasSet();
CommandObjectTargetSymbols(CommandInterpreter &interpreter) :
         CommandObjectMultiword (interpreter,
                             "target symbols",
                             "A set of commands for adding and managing debug symbol files.",
                             "target symbols <sub-command> ...")
     {
         LoadSubCommand ("add", CommandObjectSP (new CommandObjectTargetSymbolsAdd (interpreter)));
 
     }
-    virtual
-    ~CommandObjectTargetSymbols()
+
+    ~CommandObjectTargetSymbols() override
     {
     }
 
 private:
     //------------------------------------------------------------------
     // For CommandObjectTargetModules only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (CommandObjectTargetSymbols);
public:
             m_func_name_type_mask (eFunctionNameTypeAuto),
             m_sym_ctx_specified (false),
             m_thread_specified (false),
             m_use_one_liner (false),
             m_one_liner()
         {
         }
 
-        ~CommandOptions () {}
+        ~CommandOptions () override {}
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
-        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;
             bool success;
 
             switch (short_option)
             {
                 case 'c':
public:
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option %c.", short_option);
                 break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_class_name.clear();
             m_function_name.clear();
             m_line_start = 0;
             m_line_end = UINT_MAX;
             m_file_name.clear();
             m_module_name.clear();
             m_func_name_type_mask = eFunctionNameTypeAuto;
public:
         bool        m_no_inlines;
         bool        m_thread_specified;
         // Instance variables to hold the values for one_liner options.
         bool m_use_one_liner;
         std::string m_one_liner;
     };
 
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
     CommandObjectTargetStopHookAdd (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "target stop-hook add",
                              "Add a hook to be executed when the target stops.",
                              "target stop-hook add"),
         IOHandlerDelegateMultiline ("DONE", IOHandlerDelegate::Completion::LLDBCommand),
         m_options (interpreter)
     {
     }
 
-    ~CommandObjectTargetStopHookAdd ()
+    ~CommandObjectTargetStopHookAdd () override
     {
     }
 
 protected:
-    virtual void
-    IOHandlerActivated (IOHandler &io_handler)
+    void
+    IOHandlerActivated (IOHandler &io_handler) override
     {
         StreamFileSP output_sp(io_handler.GetOutputStreamFile());
         if (output_sp)
         {
             output_sp->PutCString("Enter your stop hook command(s).  Type 'DONE' to end.\n");
             output_sp->Flush();
         }
     }
 
-    virtual void
-    IOHandlerInputComplete (IOHandler &io_handler, std::string &line)
+    void
+    IOHandlerInputComplete (IOHandler &io_handler, std::string &line) override
     {
         if (m_stop_hook_sp)
         {
             if (line.empty())
             {
                 StreamFileSP error_sp(io_handler.GetErrorStreamFile());
                 if (error_sp)
                 {
IOHandlerInputComplete (IOHandler &io_handler, std::string &line) override
                 }
             }
             m_stop_hook_sp.reset();
         }
         io_handler.SetIsDone(true);
     }
 
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         m_stop_hook_sp.reset();
 
         Target *target = GetSelectedOrDummyTarget();
         if (target)
         {
             Target::StopHookSP new_hook_sp = target->CreateStopHook();
 
public:
     CommandObjectTargetStopHookDelete (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "target stop-hook delete",
                              "Delete a stop-hook.",
                              "target stop-hook delete [<idx>]")
     {
     }
 
-    ~CommandObjectTargetStopHookDelete ()
+    ~CommandObjectTargetStopHookDelete () override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = GetSelectedOrDummyTarget();
         if (target)
         {
             // FIXME: see if we can use the breakpoint id style parser?
             size_t num_args = command.GetArgumentCount();
             if (num_args == 0)
             {
CommandObjectTargetStopHookEnableDisable (CommandInterpreter &interpreter, bool enable, const char *name, const char *help, const char *syntax) :
         CommandObjectParsed (interpreter,
                              name,
                              help,
                              syntax),
         m_enable (enable)
     {
     }
 
-    ~CommandObjectTargetStopHookEnableDisable ()
+    ~CommandObjectTargetStopHookEnableDisable () override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = GetSelectedOrDummyTarget();
         if (target)
         {
             // FIXME: see if we can use the breakpoint id style parser?
             size_t num_args = command.GetArgumentCount();
             bool success;
 
public:
     CommandObjectTargetStopHookList (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "target stop-hook list",
                              "List all stop-hooks.",
                              "target stop-hook list [<type>]")
     {
     }
 
-    ~CommandObjectTargetStopHookList ()
+    ~CommandObjectTargetStopHookList () override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = GetSelectedOrDummyTarget();
         if (!target)
         {
             result.AppendError ("invalid target\n");
             result.SetStatus (eReturnStatusFailed);
             return result.Succeeded();
         }
CommandObjectMultiwordTargetStopHooks (CommandInterpreter &interpreter) :
         LoadSubCommand ("enable",   CommandObjectSP (new CommandObjectTargetStopHookEnableDisable (interpreter, 
                                                                                                    true, 
                                                                                                    "target stop-hook enable [<id>]",
                                                                                                    "Enable a stop-hook.",
                                                                                                    "target stop-hook enable")));
         LoadSubCommand ("list",     CommandObjectSP (new CommandObjectTargetStopHookList (interpreter)));
     }
 
-    ~CommandObjectMultiwordTargetStopHooks()
+    ~CommandObjectMultiwordTargetStopHooks() override
     {
     }
 };
 
 
 
 #pragma mark CommandObjectMultiwordTarget
 

source/Commands/CommandObjectThread.cpp

CommandObjectIterateOverThreads (CommandInterpreter &interpreter,
                          const char *name,
                          const char *help,
                          const char *syntax,
                          uint32_t flags) :
         CommandObjectParsed (interpreter, name, help, syntax, flags)
     {
     }
 
-    virtual ~CommandObjectIterateOverThreads() {}
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    ~CommandObjectIterateOverThreads() override {}
+
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {        
         result.SetStatus (m_success_return);
 
         if (command.GetArgumentCount() == 0)
         {
             Thread *thread = m_exe_ctx.GetThreadPtr();
             if (!HandleOneThread (*thread, result))
                 return false;
public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options(interpreter)
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
             OptionParsingStarting ();
         }
 
-        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 'c':
                 {
public:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
 
             }
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_count = UINT32_MAX;
             m_start = 0;
             m_extended_backtrace = false;
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
         // Options table: Required for subclasses of Options.
 
         static OptionDefinition g_option_table[];
 
CommandObjectThreadBacktrace (CommandInterpreter &interpreter) :
                              eCommandRequiresThread        |
                              eCommandTryTargetAPILock      |
                              eCommandProcessMustBeLaunched |
                              eCommandProcessMustBePaused   ),
         m_options(interpreter)
     {
     }
 
-    ~CommandObjectThreadBacktrace()
+    ~CommandObjectThreadBacktrace() override
     {
     }
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
 protected:
     void
     DoExtendedBacktrace (Thread *thread, CommandReturnObject &result)
     {
DoExtendedBacktrace (Thread *thread, CommandReturnObject &result)
                     {
                         DoExtendedBacktrace (ext_thread_sp.get(), result);
                     }
                 }
             }
         }
     }
 
-    virtual bool
-    HandleOneThread (Thread &thread, CommandReturnObject &result)
+    bool
+    HandleOneThread (Thread &thread, CommandReturnObject &result) override
     {
         Stream &strm = result.GetOutputStream();
 
         // Don't show source context when doing backtraces.
         const uint32_t num_frames_with_source = 0;
 
         if (!thread.GetStatus (strm,
                                    m_options.m_start,
public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter)
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
             OptionParsingStarting ();
         }
 
-        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':
                 {
public:
                 error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                 break;
 
             }
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_step_in_avoid_no_debug = eLazyBoolCalculate;
             m_step_out_avoid_no_debug = eLazyBoolCalculate;
             m_run_mode = eOnlyDuringStepping;
 
             // Check if we are in Non-Stop mode
             lldb::TargetSP target_sp = m_interpreter.GetDebugger().GetSelectedTarget();
             if (target_sp.get() != nullptr && target_sp->GetNonStopModeEnabled())
                 m_run_mode = eOnlyThisThread;
 
             m_avoid_regexp.clear();
             m_step_in_target.clear();
             m_class_name.clear();
             m_step_count = 1;
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
         // Options table: Required for subclasses of Options.
 
         static OptionDefinition g_option_table[];
 
CommandObjectThreadStepWithTypeAndScope (CommandInterpreter &interpreter,
         
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (thread_id_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    virtual
-    ~CommandObjectThreadStepWithTypeAndScope ()
+    ~CommandObjectThreadStepWithTypeAndScope () override
     {
     }
 
-    virtual
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Process *process = m_exe_ctx.GetProcessPtr();
         bool synchronous_execution = m_interpreter.GetSynchronous();
 
         const uint32_t num_threads = process->GetThreadList().GetSize();
         Thread *thread = NULL;
 
         if (command.GetArgumentCount() == 0)
CommandObjectThreadContinue (CommandInterpreter &interpreter) :
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (thread_idx_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
 
-    virtual
-    ~CommandObjectThreadContinue ()
+    ~CommandObjectThreadContinue () override
     {
     }
 
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         bool synchronous_execution = m_interpreter.GetSynchronous ();
 
         if (!m_interpreter.GetDebugger().GetSelectedTarget().get())
         {
             result.AppendError ("invalid target, create a debug target using the 'target create' command");
             result.SetStatus (eReturnStatusFailed);
             return false;
public:
             Options (interpreter),
             m_thread_idx(LLDB_INVALID_THREAD_ID),
             m_frame_idx(LLDB_INVALID_FRAME_ID)
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
             OptionParsingStarting ();
         }
 
-        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':
                 {
public:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
 
             }
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_thread_idx = LLDB_INVALID_THREAD_ID;
             m_frame_idx = 0;
             m_stop_others = false;
             m_until_addrs.clear();
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
         uint32_t m_step_thread_idx;
         bool m_stop_others;
         std::vector<lldb::addr_t> m_until_addrs;
 
CommandObjectThreadUntil (CommandInterpreter &interpreter) :
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (line_num_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
 
-    virtual
-    ~CommandObjectThreadUntil ()
+    ~CommandObjectThreadUntil () override
     {
     }
 
-    virtual
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         bool synchronous_execution = m_interpreter.GetSynchronous ();
 
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (target == NULL)
         {
             result.AppendError ("invalid target, create a debug target using the 'target create' command");
             result.SetStatus (eReturnStatusFailed);
CommandObjectThreadSelect (CommandInterpreter &interpreter) :
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (thread_idx_arg);
         
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
 
-    virtual
-    ~CommandObjectThreadSelect ()
+    ~CommandObjectThreadSelect () override
     {
     }
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Process *process = m_exe_ctx.GetProcessPtr();
         if (process == NULL)
         {
             result.AppendError ("no process");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
CommandObjectThreadList (CommandInterpreter &interpreter):
                              "thread list",
                              eCommandRequiresProcess       |
                              eCommandTryTargetAPILock      |
                              eCommandProcessMustBeLaunched |
                              eCommandProcessMustBePaused   )
     {
     }
 
-    ~CommandObjectThreadList()
+    ~CommandObjectThreadList() override
     {
     }
 
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Stream &strm = result.GetOutputStream();
         result.SetStatus (eReturnStatusSuccessFinishNoResult);
         Process *process = m_exe_ctx.GetProcessPtr();
         const bool only_threads_with_stop_reason = false;
         const uint32_t start_frame = 0;
         const uint32_t num_frames = 0;
         const uint32_t num_frames_with_source = 0;
public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter)
         {
             OptionParsingStarting ();
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_json_thread = false;
             m_json_stopinfo = false;
         }
 
-        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
         {
             const int short_option = m_getopt_table[option_idx].val;
             Error error;
 
             switch (short_option)
             {
                 case 'j':
                     m_json_thread = true;
                     break;
                     
                 case 's':
                     m_json_stopinfo = true;
                     break;
 
                 default:
                     return Error("invalid short option character '%c'", short_option);
 
             }
             return error;
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
         bool m_json_thread;
         bool m_json_stopinfo;
 
         static OptionDefinition g_option_table[];
     };
 
-    virtual
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
-
-    virtual
-    ~CommandObjectThreadInfo ()
+    ~CommandObjectThreadInfo () override
     {
     }
 
-    virtual bool
-    HandleOneThread (Thread &thread, CommandReturnObject &result)
+    bool
+    HandleOneThread (Thread &thread, CommandReturnObject &result) override
     {
         Stream &strm = result.GetOutputStream();
         if (!thread.GetDescription (strm, eDescriptionLevelFull, m_options.m_json_thread, m_options.m_json_stopinfo))
         {
             result.AppendErrorWithFormat ("error displaying info for thread: \"%d\"\n", thread.GetIndexID());
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
public:
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             m_from_expression (false)
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
             OptionParsingStarting ();
         }
 
-        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 'x':
                 {
public:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
 
             }
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_from_expression = false;
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
         bool m_from_expression;
 
         // Options table: Required for subclasses of Options.
 
         static OptionDefinition g_option_table[];
 
         // Instance variables to hold the values for command options.
     };
 
-    virtual
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
     CommandObjectThreadReturn (CommandInterpreter &interpreter) :
         CommandObjectRaw (interpreter,
                           "thread return",
                           "Return from the currently selected frame, short-circuiting execution of the frames below it, with an optional return value,"
CommandObjectThreadReturn (CommandInterpreter &interpreter) :
         arg.push_back (expression_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
         
         
     }
     
-    ~CommandObjectThreadReturn()
+    ~CommandObjectThreadReturn() override
     {
     }
     
 protected:
 
-    bool DoExecute
-    (
-        const char *command,
-        CommandReturnObject &result
-    )
+    bool
+    DoExecute (const char *command, CommandReturnObject &result) override
     {
         // I am going to handle this by hand, because I don't want you to have to say:
         // "thread return -- -5".
         if (command[0] == '-' && command[1] == 'x')
         {
             if (command && command[2] != '\0')
                 result.AppendWarning("Return values ignored when returning from user called expressions");
             
public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter)
         {
             OptionParsingStarting ();
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_filenames.Clear();
             m_line_num = 0;
             m_line_offset = 0;
             m_load_addr = LLDB_INVALID_ADDRESS;
             m_force = false;
         }
 
-        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
         {
             bool success;
             const int short_option = m_getopt_table[option_idx].val;
             Error error;
 
             switch (short_option)
             {
                 case 'f':
public:
                  default:
                     return Error("invalid short option character '%c'", short_option);
 
             }
             return error;
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
         FileSpecList m_filenames;
         uint32_t m_line_num;
         int32_t m_line_offset;
         lldb::addr_t m_load_addr;
         bool m_force;
 
         static OptionDefinition g_option_table[];
     };
 
-    virtual
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_options;
     }
 
     CommandObjectThreadJump (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                           "thread jump",
                           "Sets the program counter to a new address.",
                           "thread jump",
                           eCommandRequiresFrame         |
                           eCommandTryTargetAPILock      |
                           eCommandProcessMustBeLaunched |
                           eCommandProcessMustBePaused   ),
         m_options (interpreter)
     {
     }
 
-    ~CommandObjectThreadJump()
+    ~CommandObjectThreadJump() override
     {
     }
 
 protected:
 
-    bool DoExecute (Args& args, CommandReturnObject &result)
+    bool DoExecute (Args& args, CommandReturnObject &result) override
     {
         RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext();
         StackFrame *frame = m_exe_ctx.GetFramePtr();
         Thread *thread = m_exe_ctx.GetThreadPtr();
         Target *target = m_exe_ctx.GetTargetPtr();
         const SymbolContext &sym_ctx = frame->GetSymbolContext (eSymbolContextLineEntry);
 
         if (m_options.m_load_addr != LLDB_INVALID_ADDRESS)
public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options(interpreter)
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
             OptionParsingStarting ();
         }
 
-        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 'i':
                 {
public:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
 
             }
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_verbose = false;
             m_internal = false;
         }
 
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
 
         // Options table: Required for subclasses of Options.
 
         static OptionDefinition g_option_table[];
 
CommandObjectThreadPlanList (CommandInterpreter &interpreter) :
                                          eCommandRequiresThread        |
                                          eCommandTryTargetAPILock      |
                                          eCommandProcessMustBeLaunched |
                                          eCommandProcessMustBePaused   ),
         m_options(interpreter)
     {
     }
 
-    ~CommandObjectThreadPlanList ()
+    ~CommandObjectThreadPlanList () override
     {
     }
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
 protected:
-    virtual bool
-    HandleOneThread (Thread &thread, CommandReturnObject &result)
+    bool
+    HandleOneThread (Thread &thread, CommandReturnObject &result) override
     {
         Stream &strm = result.GetOutputStream();
         DescriptionLevel desc_level = eDescriptionLevelFull;
         if (m_options.m_verbose)
             desc_level = eDescriptionLevelVerbose;
 
         thread.DumpThreadPlans (&strm, desc_level, m_options.m_internal, true);
         return true;
CommandObjectThreadPlanDiscard (CommandInterpreter &interpreter) :
 
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (plan_index_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    virtual ~CommandObjectThreadPlanDiscard () {}
+    ~CommandObjectThreadPlanDiscard () override {}
 
     bool
-    DoExecute (Args& args, CommandReturnObject &result)
+    DoExecute (Args& args, CommandReturnObject &result) override
     {
         Thread *thread = m_exe_ctx.GetThreadPtr();
         if (args.GetArgumentCount() != 1)
         {
             result.AppendErrorWithFormat("Too many arguments, expected one - the thread plan index - but got %zu.",
                                          args.GetArgumentCount());
             result.SetStatus (eReturnStatusFailed);
             return false;
CommandObjectMultiwordThreadPlan(CommandInterpreter &interpreter) :
                                 "plan",
                                 "A set of subcommands for accessing the thread plans controlling execution control on one or more threads.",
                                 "thread plan <subcommand> [<subcommand objects]")
     {
         LoadSubCommand ("list", CommandObjectSP (new CommandObjectThreadPlanList (interpreter)));
         LoadSubCommand ("discard", CommandObjectSP (new CommandObjectThreadPlanDiscard (interpreter)));
     }
 
-    virtual ~CommandObjectMultiwordThreadPlan () {}
+    ~CommandObjectMultiwordThreadPlan () override {}
 
 
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectMultiwordThread
 //-------------------------------------------------------------------------
 

source/Commands/CommandObjectType.cpp

private:
     {
     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;
         
         void
-        OptionParsingStarting ();
+        OptionParsingStarting () override;
         
         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.
         
         TypeSummaryImpl::Flags m_flags;
         bool m_regex;
         std::string m_format_string;
         ConstString m_name;
         std::string m_python_script;
         std::string m_python_function;
         bool m_is_add_script;
         std::string m_category;
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
     bool
     Execute_ScriptSummary (Args& command, CommandReturnObject &result);
     
     bool
     Execute_StringSummary (Args& command, CommandReturnObject &result);
     
 public:
     
     enum SummaryFormatType
     {
         eRegularSummary,
         eRegexSummary,
         eNamedSummary
     };
     
     CommandObjectTypeSummaryAdd (CommandInterpreter &interpreter);
     
-    ~CommandObjectTypeSummaryAdd ()
+    ~CommandObjectTypeSummaryAdd () override
     {
     }
     
-    virtual void
-    IOHandlerActivated (IOHandler &io_handler)
+    void
+    IOHandlerActivated (IOHandler &io_handler) override
     {
         static const char *g_summary_addreader_instructions = "Enter your Python command(s). Type 'DONE' to end.\n"
         "def function (valobj,internal_dict):\n"
         "     \"\"\"valobj: an SBValue which you want to provide a summary for\n"
         "        internal_dict: an LLDB support object not to be used\"\"\"\n";
 
         StreamFileSP output_sp(io_handler.GetOutputStreamFile());
         if (output_sp)
         {
             output_sp->PutCString(g_summary_addreader_instructions);
             output_sp->Flush();
         }
     }
     
     
-    virtual void
-    IOHandlerInputComplete (IOHandler &io_handler, std::string &data)
+    void
+    IOHandlerInputComplete (IOHandler &io_handler, std::string &data) override
     {
         StreamFileSP error_sp = io_handler.GetErrorStreamFile();
         
 #ifndef LLDB_DISABLE_PYTHON
         ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
         if (interpreter)
         {
             StringList lines;
#endif // #ifndef LLDB_DISABLE_PYTHON
     static bool
     AddSummary(ConstString type_name,
                lldb::TypeSummaryImplSP entry,
                SummaryFormatType type,
                std::string category,
                Error* error = NULL);
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result);
+    DoExecute (Args& command, CommandReturnObject &result) override;
     
 };
 
 static const char *g_synth_addreader_instructions =   "Enter your Python command(s). Type 'DONE' to end.\n"
 "You must define a Python class with these methods:\n"
 "    def __init__(self, valobj, dict):\n"
 "    def num_children(self):\n"
 "    def get_child_at_index(self, index):\n"
private:
     {
     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;
             bool success;
             
             switch (short_option)
             {
                 case 'C':
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_cascade = true;
             m_class_name = "";
             m_skip_pointers = false;
             m_skip_references = false;
             m_category = "default";
             is_class_based = false;
             handwrite_python = false;
             m_regex = false;
         }
         
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
         
         // Options table: Required for subclasses of Options.
         
         static OptionDefinition g_option_table[];
         
public:
         bool handwrite_python;
         
         bool m_regex;
         
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
     bool
     Execute_HandwritePython (Args& command, CommandReturnObject &result);
     
     bool
     Execute_PythonClass (Args& command, CommandReturnObject &result);
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         WarnOnPotentialUnquotedUnsignedType(command, result);
         
         if (m_options.handwrite_python)
             return Execute_HandwritePython(command, result);
         else if (m_options.is_class_based)
             return Execute_PythonClass(command, result);
         else
         {
             result.AppendError("must either provide a children list, a Python class name, or use -P and type a Python class line-by-line");
             result.SetStatus(eReturnStatusFailed);
             return false;
         }
     }
     
-    virtual void
-    IOHandlerActivated (IOHandler &io_handler)
+    void
+    IOHandlerActivated (IOHandler &io_handler) override
     {
         StreamFileSP output_sp(io_handler.GetOutputStreamFile());
         if (output_sp)
         {
             output_sp->PutCString(g_synth_addreader_instructions);
             output_sp->Flush();
         }
     }
     
     
-    virtual void
-    IOHandlerInputComplete (IOHandler &io_handler, std::string &data)
+    void
+    IOHandlerInputComplete (IOHandler &io_handler, std::string &data) override
     {
         StreamFileSP error_sp = io_handler.GetErrorStreamFile();
         
 #ifndef LLDB_DISABLE_PYTHON
         ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
         if (interpreter)
         {
             StringList lines;
public:
     enum SynthFormatType
     {
         eRegularSynth,
         eRegexSynth
     };
     
     CommandObjectTypeSynthAdd (CommandInterpreter &interpreter);
     
-    ~CommandObjectTypeSynthAdd ()
+    ~CommandObjectTypeSynthAdd () override
     {
     }
     
     static bool
     AddSynth(ConstString type_name,
              lldb::SyntheticChildrenSP entry,
              SynthFormatType type,
              std::string category_name,
private:
     {
     public:
         
         CommandOptions () :
             OptionGroup()
         {
         }
         
-        virtual
-        ~CommandOptions ()
+        ~CommandOptions () override
         {
         }
         
-        virtual uint32_t
-        GetNumDefinitions ();
+        uint32_t
+        GetNumDefinitions () override;
         
-        virtual const OptionDefinition*
-        GetDefinitions ()
+        const OptionDefinition*
+        GetDefinitions () override
         {
             return g_option_table;
         }
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter)
+        void
+        OptionParsingStarting (CommandInterpreter &interpreter) override
         {
             m_cascade = true;
             m_skip_pointers = false;
             m_skip_references = false;
             m_regex = false;
             m_category.assign("default");
             m_custom_type_name.clear();
         }
-        virtual Error
+        Error
         SetOptionValue (CommandInterpreter &interpreter,
                         uint32_t option_idx,
-                        const char *option_value)
+                        const char *option_value) override
         {
             Error error;
             const int short_option = g_option_table[option_idx].short_option;
             bool success;
             
             switch (short_option)
             {
                 case 'C':
public:
         std::string m_category;
         std::string m_custom_type_name;
     };
     
     OptionGroupOptions m_option_group;
     OptionGroupFormat m_format_options;
     CommandOptions m_command_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_option_group;
     }
     
 public:
     CommandObjectTypeFormatAdd (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "type format add",
pointers to floats.  Nor will it change the default display for Afloat and Bfloat objects."
     
         // Add the "--format" to all options groups
         m_option_group.Append (&m_format_options, OptionGroupFormat::OPTION_GROUP_FORMAT, LLDB_OPT_SET_1);
         m_option_group.Append (&m_command_options);
         m_option_group.Finalize();
 
     }
     
-    ~CommandObjectTypeFormatAdd ()
+    ~CommandObjectTypeFormatAdd () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         if (argc < 1)
         {
             result.AppendErrorWithFormat ("%s takes one or more args.\n", m_cmd_name.c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;
private:
     {
     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_delete_all = true;
                     break;
                 case 'w':
                     m_category = std::string(option_arg);
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_delete_all = false;
             m_category = "default";
         }
         
         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_delete_all;
         std::string m_category;
         
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
     static bool
     PerCategoryCallback(void* param,
                         const lldb::TypeCategoryImplSP& category_sp)
     {
m_options(interpreter)
         type_style_arg.arg_repetition = eArgRepeatPlain;
         
         type_arg.push_back (type_style_arg);
         
         m_arguments.push_back (type_arg);
         
     }
     
-    ~CommandObjectTypeFormatDelete ()
+    ~CommandObjectTypeFormatDelete () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         if (argc != 1)
         {
             result.AppendErrorWithFormat ("%s takes 1 arg.\n", m_cmd_name.c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;
private:
     {
     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_delete_all = true;
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_delete_all = 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_delete_all;
         bool m_delete_named;
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
     static bool
     PerCategoryCallback(void* param,
                         const lldb::TypeCategoryImplSP& cate)
     {
         cate->GetTypeFormatsContainer()->Clear();
         cate->GetRegexTypeFormatsContainer()->Clear();
         return true;
         
     }
     
 public:
     CommandObjectTypeFormatClear (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "type format clear",
                              "Delete all existing format styles.",
                              NULL),
     m_options(interpreter)
     {
     }
     
-    ~CommandObjectTypeFormatClear ()
+    ~CommandObjectTypeFormatClear () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         if (m_options.m_delete_all)
             DataVisualization::Categories::LoopThrough(PerCategoryCallback, NULL);
         
         else
         {
             lldb::TypeCategoryImplSP category;
             if (command.GetArgumentCount() > 0)
class CommandObjectTypeFormatList : public CommandObjectParsed
     {
     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 'w':
                     m_category_regex = std::string(option_arg);
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_category_regex = "";
         }
         
         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.
         
         std::string m_category_regex;
         
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
 public:
     CommandObjectTypeFormatList (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "type format list",
                              "Show a list of current formatting styles.",
                              NULL),
     m_options(interpreter)
     {
         CommandArgumentEntry type_arg;
         CommandArgumentData type_style_arg;
         
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatOptional;
         
         type_arg.push_back (type_style_arg);
         
         m_arguments.push_back (type_arg);
     }
     
-    ~CommandObjectTypeFormatList ()
+    ~CommandObjectTypeFormatList () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         CommandObjectTypeFormatList_LoopCallbackParam *param;
         RegularExpression* cate_regex =
         m_options.m_category_regex.empty() ? NULL :
         new RegularExpression(m_options.m_category_regex.c_str());
         
private:
     {
     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_delete_all = true;
                     break;
                 case 'w':
                     m_category = std::string(option_arg);
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_delete_all = false;
             m_category = "default";
         }
         
         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_delete_all;
         std::string m_category;
         
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
     static bool
     PerCategoryCallback(void* param,
                         const lldb::TypeCategoryImplSP& category_sp)
     {
CommandObjectTypeSummaryDelete (CommandInterpreter &interpreter) :
         type_style_arg.arg_repetition = eArgRepeatPlain;
         
         type_arg.push_back (type_style_arg);
         
         m_arguments.push_back (type_arg);
         
     }
     
-    ~CommandObjectTypeSummaryDelete ()
+    ~CommandObjectTypeSummaryDelete () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         if (argc != 1)
         {
             result.AppendErrorWithFormat ("%s takes 1 arg.\n", m_cmd_name.c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;
private:
     {
     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_delete_all = true;
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_delete_all = 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_delete_all;
         bool m_delete_named;
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
     static bool
     PerCategoryCallback(void* param,
                         const lldb::TypeCategoryImplSP& cate)
     {
         cate->GetTypeSummariesContainer()->Clear();
         cate->GetRegexTypeSummariesContainer()->Clear();
         return true;
         
     }
     
 public:
     CommandObjectTypeSummaryClear (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "type summary clear",
                              "Delete all existing summary styles.",
                              NULL),
         m_options(interpreter)
     {
     }
     
-    ~CommandObjectTypeSummaryClear ()
+    ~CommandObjectTypeSummaryClear () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         
         if (m_options.m_delete_all)
             DataVisualization::Categories::LoopThrough(PerCategoryCallback, NULL);
         
         else
         {        
             lldb::TypeCategoryImplSP category;
class CommandObjectTypeSummaryList : public CommandObjectParsed
     {
     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 'w':
                     m_category_regex = std::string(option_arg);
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_category_regex = "";
         }
         
         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.
         
         std::string m_category_regex;
         
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
 public:
     CommandObjectTypeSummaryList (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "type summary list",
                              "Show a list of current summary styles.",
                              NULL),
         m_options(interpreter)
     {
         CommandArgumentEntry type_arg;
         CommandArgumentData type_style_arg;
         
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatOptional;
         
         type_arg.push_back (type_style_arg);
         
         m_arguments.push_back (type_arg);
     }
     
-    ~CommandObjectTypeSummaryList ()
+    ~CommandObjectTypeSummaryList () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         CommandObjectTypeSummaryList_LoopCallbackParam *param;
         RegularExpression* cate_regex = 
         m_options.m_category_regex.empty() ? NULL :
         new RegularExpression(m_options.m_category_regex.c_str());
         
public:
         
         CommandOptions (CommandInterpreter &interpreter) :
         Options (interpreter),
         m_define_enabled(false,false),
         m_cate_language(eLanguageTypeUnknown,eLanguageTypeUnknown)
         {
         }
         
-        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 'e':
                     m_define_enabled.SetValueFromString("true");
                     break;
                 case 'l':
                     error = m_cate_language.SetValueFromString(option_arg);
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_define_enabled.Clear();
             m_cate_language.Clear();
         }
         
         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.
         
         OptionValueBoolean m_define_enabled;
         OptionValueLanguage m_cate_language;
         
         
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
 public:
     CommandObjectTypeCategoryDefine (CommandInterpreter &interpreter) :
     CommandObjectParsed (interpreter,
                          "type category define",
                          "Define a new category as a source of formatters.",
                          NULL),
     m_options(interpreter)
     {
         CommandArgumentEntry type_arg;
         CommandArgumentData type_style_arg;
         
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatPlus;
         
         type_arg.push_back (type_style_arg);
         
         m_arguments.push_back (type_arg);
         
     }
     
-    ~CommandObjectTypeCategoryDefine ()
+    ~CommandObjectTypeCategoryDefine () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         if (argc < 1)
         {
             result.AppendErrorWithFormat ("%s takes 1 or more args.\n", m_cmd_name.c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;
class CommandObjectTypeCategoryEnable : public CommandObjectParsed
     {
     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 'l':
                     if (option_arg)
                     {
                         m_language = Language::GetLanguageTypeFromString(option_arg);
                         if (m_language == lldb::eLanguageTypeUnknown)
                             error.SetErrorStringWithFormat ("unrecognized language '%s'", option_arg);
                     }
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_language = lldb::eLanguageTypeUnknown;
         }
         
         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.
         
         lldb::LanguageType m_language;
         
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
 public:
     CommandObjectTypeCategoryEnable (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "type category enable",
                              "Enable a category as a source of formatters.",
                              NULL),
         m_options(interpreter)
     {
         CommandArgumentEntry type_arg;
         CommandArgumentData type_style_arg;
         
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatPlus;
         
         type_arg.push_back (type_style_arg);
         
         m_arguments.push_back (type_arg);
         
     }
     
-    ~CommandObjectTypeCategoryEnable ()
+    ~CommandObjectTypeCategoryEnable () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         if (argc < 1 &&
             m_options.m_language == lldb::eLanguageTypeUnknown)
         {
             result.AppendErrorWithFormat ("%s takes arguments and/or a language", m_cmd_name.c_str());
             result.SetStatus(eReturnStatusFailed);
CommandObjectTypeCategoryDelete (CommandInterpreter &interpreter) :
         type_style_arg.arg_repetition = eArgRepeatPlus;
                 
         type_arg.push_back (type_style_arg);
         
         m_arguments.push_back (type_arg);
         
     }
     
-    ~CommandObjectTypeCategoryDelete ()
+    ~CommandObjectTypeCategoryDelete () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         if (argc < 1)
         {
             result.AppendErrorWithFormat ("%s takes 1 or more arg.\n", m_cmd_name.c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;
class CommandObjectTypeCategoryDisable : public CommandObjectParsed
     {
     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 'l':
                     if (option_arg)
                     {
                         m_language = Language::GetLanguageTypeFromString(option_arg);
                         if (m_language == lldb::eLanguageTypeUnknown)
                             error.SetErrorStringWithFormat ("unrecognized language '%s'", option_arg);
                     }
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_language = lldb::eLanguageTypeUnknown;
         }
         
         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.
         
         lldb::LanguageType m_language;
         
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
 public:
     CommandObjectTypeCategoryDisable (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "type category disable",
                              "Disable a category as a source of formatters.",
                              NULL),
         m_options(interpreter)
     {
         CommandArgumentEntry type_arg;
         CommandArgumentData type_style_arg;
         
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatPlus;
         
         type_arg.push_back (type_style_arg);
         
         m_arguments.push_back (type_arg);
         
     }
     
-    ~CommandObjectTypeCategoryDisable ()
+    ~CommandObjectTypeCategoryDisable () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         if (argc < 1 &&
             m_options.m_language == lldb::eLanguageTypeUnknown)
         {
             result.AppendErrorWithFormat ("%s takes arguments and/or a language", m_cmd_name.c_str());
             result.SetStatus(eReturnStatusFailed);
CommandObjectTypeCategoryList (CommandInterpreter &interpreter) :
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatOptional;
         
         type_arg.push_back (type_style_arg);
         
         m_arguments.push_back (type_arg);
     }
     
-    ~CommandObjectTypeCategoryList ()
+    ~CommandObjectTypeCategoryList () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         RegularExpression* regex = NULL;
         
         if (argc == 0)
             ;
         else if (argc == 1)
             regex = new RegularExpression(command.GetArgumentAtIndex(0));
class CommandObjectTypeFilterList : public CommandObjectParsed
     {
     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 'w':
                     m_category_regex = std::string(option_arg);
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_category_regex = "";
         }
         
         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.
         
         std::string m_category_regex;
         
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
 public:
     CommandObjectTypeFilterList (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "type filter list",
                              "Show a list of current filters.",
                              NULL),
         m_options(interpreter)
     {
         CommandArgumentEntry type_arg;
         CommandArgumentData type_style_arg;
         
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatOptional;
         
         type_arg.push_back (type_style_arg);
         
         m_arguments.push_back (type_arg);
     }
     
-    ~CommandObjectTypeFilterList ()
+    ~CommandObjectTypeFilterList () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         CommandObjectTypeFilterList_LoopCallbackParam *param;
         RegularExpression* cate_regex = 
         m_options.m_category_regex.empty() ? NULL :
         new RegularExpression(m_options.m_category_regex.c_str());
         
class CommandObjectTypeSynthList : public CommandObjectParsed
     {
     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 'w':
                     m_category_regex = std::string(option_arg);
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_category_regex = "";
         }
         
         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.
         
         std::string m_category_regex;
         
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
 public:
     CommandObjectTypeSynthList (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "type synthetic list",
                              "Show a list of current synthetic providers.",
                              NULL),
         m_options(interpreter)
     {
         CommandArgumentEntry type_arg;
         CommandArgumentData type_style_arg;
         
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatOptional;
         
         type_arg.push_back (type_style_arg);
         
         m_arguments.push_back (type_arg);
     }
     
-    ~CommandObjectTypeSynthList ()
+    ~CommandObjectTypeSynthList () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         CommandObjectTypeSynthList_LoopCallbackParam *param;
         RegularExpression* cate_regex = 
         m_options.m_category_regex.empty() ? NULL :
         new RegularExpression(m_options.m_category_regex.c_str());
         
private:
     {
     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_delete_all = true;
                     break;
                 case 'w':
                     m_category = std::string(option_arg);
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_delete_all = false;
             m_category = "default";
         }
         
         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_delete_all;
         std::string m_category;
         
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
     static bool
     PerCategoryCallback(void* param,
                         const lldb::TypeCategoryImplSP& cate)
     {
CommandObjectTypeFilterDelete (CommandInterpreter &interpreter) :
         type_style_arg.arg_repetition = eArgRepeatPlain;
         
         type_arg.push_back (type_style_arg);
         
         m_arguments.push_back (type_arg);
         
     }
     
-    ~CommandObjectTypeFilterDelete ()
+    ~CommandObjectTypeFilterDelete () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         if (argc != 1)
         {
             result.AppendErrorWithFormat ("%s takes 1 arg.\n", m_cmd_name.c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;
private:
     {
     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_delete_all = true;
                     break;
                 case 'w':
                     m_category = std::string(option_arg);
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_delete_all = false;
             m_category = "default";
         }
         
         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_delete_all;
         std::string m_category;
         
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
     static bool
     PerCategoryCallback(void* param,
                         const lldb::TypeCategoryImplSP& cate)
     {
CommandObjectTypeSynthDelete (CommandInterpreter &interpreter) :
         type_style_arg.arg_repetition = eArgRepeatPlain;
         
         type_arg.push_back (type_style_arg);
         
         m_arguments.push_back (type_arg);
         
     }
     
-    ~CommandObjectTypeSynthDelete ()
+    ~CommandObjectTypeSynthDelete () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         if (argc != 1)
         {
             result.AppendErrorWithFormat ("%s takes 1 arg.\n", m_cmd_name.c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;
private:
     {
     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_delete_all = true;
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_delete_all = 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_delete_all;
         bool m_delete_named;
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
     static bool
     PerCategoryCallback(void* param,
                         const lldb::TypeCategoryImplSP& cate)
     {
         cate->Clear(eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter);
         return true;
         
     }
     
 public:
     CommandObjectTypeFilterClear (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "type filter clear",
                              "Delete all existing filters.",
                              NULL),
         m_options(interpreter)
     {
     }
     
-    ~CommandObjectTypeFilterClear ()
+    ~CommandObjectTypeFilterClear () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         
         if (m_options.m_delete_all)
             DataVisualization::Categories::LoopThrough(PerCategoryCallback, NULL);
         
         else
         {        
             lldb::TypeCategoryImplSP category;
private:
     {
     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_delete_all = true;
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_delete_all = 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_delete_all;
         bool m_delete_named;
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
     static bool
     PerCategoryCallback(void* param,
                         const lldb::TypeCategoryImplSP& cate)
     {
         cate->Clear(eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth);
         return true;
         
     }
     
 public:
     CommandObjectTypeSynthClear (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "type synthetic clear",
                              "Delete all existing synthetic providers.",
                              NULL),
         m_options(interpreter)
     {
     }
     
-    ~CommandObjectTypeSynthClear ()
+    ~CommandObjectTypeSynthClear () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         
         if (m_options.m_delete_all)
             DataVisualization::Categories::LoopThrough(PerCategoryCallback, NULL);
         
         else
         {        
             lldb::TypeCategoryImplSP category;
class CommandOptions : public Options
         typedef std::vector<std::string> option_vector;
     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;
             bool success;
             
             switch (short_option)
             {
                 case 'C':
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_cascade = true;
             m_skip_pointers = false;
             m_skip_references = false;
             m_category = "default";
             m_expr_paths.clear();
             has_child_list = false;
             m_regex = false;
         }
         
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions () override
         {
             return g_option_table;
         }
         
         // Options table: Required for subclasses of Options.
         
         static OptionDefinition g_option_table[];
         
public:
         
         bool m_regex;
         
         typedef option_vector::iterator ExpressionPathsIterator;
     };
     
     CommandOptions m_options;
     
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
     
     enum FilterFormatType
     {
         eRegularFilter,
         eRegexFilter

 
 )" "The formatting option --raw on frame variable bypasses the filter, showing \
 all children of my_foo as if no filter was defined:" R"(
 
 (lldb) frame variable my_foo --raw)"
         );
     }
     
-    ~CommandObjectTypeFilterAdd ()
+    ~CommandObjectTypeFilterAdd () override
     {
     }
     
 protected:
     bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
         
         if (argc < 1)
         {
             result.AppendErrorWithFormat ("%s takes one or more args.\n", m_cmd_name.c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;
protected:
     public:
         
         CommandOptions () :
         OptionGroup(),
         m_show_help(false),
         m_language(eLanguageTypeUnknown)
         {}
         
-        virtual
-        ~CommandOptions () {}
+        ~CommandOptions () override {}
         
-        virtual uint32_t
-        GetNumDefinitions ()
+        uint32_t
+        GetNumDefinitions () override
         {
             return 3;
         }
         
-        virtual const OptionDefinition*
-        GetDefinitions ()
+        const OptionDefinition*
+        GetDefinitions () override
         {
             return g_option_table;
         }
         
-        virtual Error
+        Error
         SetOptionValue (CommandInterpreter &interpreter,
                         uint32_t option_idx,
-                        const char *option_value)
+                        const char *option_value) override
         {
             Error error;
             
             const int short_option = g_option_table[option_idx].short_option;
             
             switch (short_option)
             {
                 case 'h':
                     m_show_help = true;
                     break;
                     
                 case 'l':
                     m_language = Language::GetLanguageTypeFromString(option_value);
                     break;
                     
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter)
+        void
+        OptionParsingStarting (CommandInterpreter &interpreter) override
         {
             m_show_help = false;
             m_language = eLanguageTypeUnknown;
         }
         
         // Options table: Required for subclasses of Options.
         
         static OptionDefinition g_option_table[];
CommandObjectRaw (interpreter,
                       eCommandRequiresTarget),
     m_option_group(interpreter),
     m_command_options()
     {
         m_option_group.Append(&m_command_options);
         m_option_group.Finalize();
     }
     
-    virtual
-    ~CommandObjectTypeLookup ()
+    ~CommandObjectTypeLookup () override
     {
     }
     
-    virtual
     Options *
-    GetOptions ()
+    GetOptions () override
     {
         return &m_option_group;
     }
     
-    virtual bool
-    DoExecute (const char *raw_command_line, CommandReturnObject &result)
+    bool
+    DoExecute (const char *raw_command_line, CommandReturnObject &result) override
     {
         if (!raw_command_line || !raw_command_line[0])
         {
             result.SetError("type lookup cannot be invoked without a type name as argument");
             return false;
         }
         
         m_option_group.NotifyOptionParsingStarting();
m_discovery_function(discovery_func)
         StreamString help;
         help.Printf("This command evaluates the provided expression and shows which %s is applied to the resulting value (if any).", formatter_name);
         SetHelp(help.GetData());
         StreamString syntax;
         syntax.Printf("type %s info <expr>", formatter_name);
         SetSyntax(syntax.GetData());
     }
     
-    virtual
-    ~CommandObjectFormatterInfo ()
+    ~CommandObjectFormatterInfo () override
     {
     }
     
 protected:
-    virtual bool
-    DoExecute (const char *command, CommandReturnObject &result)
+    bool
+    DoExecute (const char *command, CommandReturnObject &result) override
     {
         auto target_sp = m_interpreter.GetDebugger().GetSelectedTarget();
         auto frame_sp = target_sp->GetProcessSP()->GetThreadList().GetSelectedThread()->GetSelectedFrame();
         ValueObjectSP result_valobj_sp;
         EvaluateExpressionOptions options;
         lldb::ExpressionResults expr_result = target_sp->EvaluateExpression(command, frame_sp.get(), result_valobj_sp, options);
         if (expr_result == eExpressionCompleted && result_valobj_sp)
         {
CommandObjectTypeFormat (CommandInterpreter &interpreter) :
         LoadSubCommand ("info",   CommandObjectSP (new CommandObjectFormatterInfo<TypeFormatImpl>(interpreter,
                                                                                                   "format",
                                                                                                   [](ValueObject& valobj) -> TypeFormatImpl::SharedPointer {
                                                                                                       return valobj.GetValueFormat();
                                                                                                   })));
     }
 
 
-    ~CommandObjectTypeFormat ()
+    ~CommandObjectTypeFormat () override
     {
     }
 };
 
 #ifndef LLDB_DISABLE_PYTHON
 
 class CommandObjectTypeSynth : public CommandObjectMultiword
 {
CommandObjectMultiword (interpreter,
         LoadSubCommand ("info",          CommandObjectSP (new CommandObjectFormatterInfo<SyntheticChildren>(interpreter,
                                                                                                             "synthetic",
                                                                                                             [](ValueObject& valobj) -> SyntheticChildren::SharedPointer {
                                                                                                                 return valobj.GetSyntheticChildren();
                                                                                                             })));
     }
     
     
-    ~CommandObjectTypeSynth ()
+    ~CommandObjectTypeSynth () override
     {
     }
 };
 
 #endif // #ifndef LLDB_DISABLE_PYTHON
 
 class CommandObjectTypeFilter : public CommandObjectMultiword
 {
 public:
     CommandObjectTypeFilter (CommandInterpreter &interpreter) :
     CommandObjectMultiword (interpreter,
                             "type filter",
                             "A set of commands for operating on type filters",
                             "type synthetic [<sub-command-options>] ")
     {
         LoadSubCommand ("add",           CommandObjectSP (new CommandObjectTypeFilterAdd (interpreter)));
         LoadSubCommand ("clear",         CommandObjectSP (new CommandObjectTypeFilterClear (interpreter)));
         LoadSubCommand ("delete",        CommandObjectSP (new CommandObjectTypeFilterDelete (interpreter)));
         LoadSubCommand ("list",          CommandObjectSP (new CommandObjectTypeFilterList (interpreter)));
     }
     
     
-    ~CommandObjectTypeFilter ()
+    ~CommandObjectTypeFilter () override
     {
     }
 };
 
 class CommandObjectTypeCategory : public CommandObjectMultiword
 {
 public:
     CommandObjectTypeCategory (CommandInterpreter &interpreter) :
     CommandObjectMultiword (interpreter,
                             "type category",
                             "A set of commands for operating on categories",
                             "type category [<sub-command-options>] ")
     {
         LoadSubCommand ("define",        CommandObjectSP (new CommandObjectTypeCategoryDefine (interpreter)));
         LoadSubCommand ("enable",        CommandObjectSP (new CommandObjectTypeCategoryEnable (interpreter)));
         LoadSubCommand ("disable",       CommandObjectSP (new CommandObjectTypeCategoryDisable (interpreter)));
         LoadSubCommand ("delete",        CommandObjectSP (new CommandObjectTypeCategoryDelete (interpreter)));
         LoadSubCommand ("list",          CommandObjectSP (new CommandObjectTypeCategoryList (interpreter)));
     }
     
     
-    ~CommandObjectTypeCategory ()
+    ~CommandObjectTypeCategory () override
     {
     }
 };
 
 class CommandObjectTypeSummary : public CommandObjectMultiword
 {
 public:
     CommandObjectTypeSummary (CommandInterpreter &interpreter) :
CommandObjectMultiword (interpreter,
         LoadSubCommand ("info",          CommandObjectSP (new CommandObjectFormatterInfo<TypeSummaryImpl>(interpreter,
                                                                                                           "summary",
                                                                                                             [](ValueObject& valobj) -> TypeSummaryImpl::SharedPointer {
                                                                                                                 return valobj.GetSummaryFormat();
                                                                                                             })));
     }
     
     
-    ~CommandObjectTypeSummary ()
+    ~CommandObjectTypeSummary () override
     {
     }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectType
 //-------------------------------------------------------------------------
 

source/Commands/CommandObjectWatchpoint.cpp

CommandObjectWatchpointList (CommandInterpreter &interpreter) :
         m_options(interpreter)
     {
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back(arg);
     }
 
-    virtual
-    ~CommandObjectWatchpointList () {}
+    ~CommandObjectWatchpointList () override {}
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options(interpreter),
             m_level(lldb::eDescriptionLevelBrief) // Watchpoint List defaults to brief descriptions
         {
         }
 
-        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 'b':
                     m_level = lldb::eDescriptionLevelBrief;
                     break;
                 case 'f':
                     m_level = lldb::eDescriptionLevelFull;
                     break;
                 case 'v':
                     m_level = lldb::eDescriptionLevelVerbose;
                     break;
                 default:
                     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_level = lldb::eDescriptionLevelFull;
         }
 
         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.
 
         lldb::DescriptionLevel m_level;
     };
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (target == NULL)
         {
             result.AppendError ("Invalid target. No current target or watchpoints.");
             result.SetStatus (eReturnStatusSuccessFinishNoResult);
             return true;
         }
CommandObjectWatchpointEnable (CommandInterpreter &interpreter) :
                              NULL)
     {
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back(arg);
     }
 
-    virtual
-    ~CommandObjectWatchpointEnable () {}
+    ~CommandObjectWatchpointEnable () override {}
 
 protected:
-    virtual bool
+    bool
     DoExecute (Args& command,
-             CommandReturnObject &result)
+             CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (!CheckTargetForWatchpointOperations(target, result))
             return false;
 
         Mutex::Locker locker;
         target->GetWatchpointList().GetListMutex(locker);
 
public:
     {
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back(arg);
     }
 
 
-    virtual
-    ~CommandObjectWatchpointDisable () {}
+    ~CommandObjectWatchpointDisable () override {}
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (!CheckTargetForWatchpointOperations(target, result))
             return false;
 
         Mutex::Locker locker;
         target->GetWatchpointList().GetListMutex(locker);
 
CommandObjectWatchpointDelete (CommandInterpreter &interpreter) :
                             NULL)
     {
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back(arg);
     }
 
-    virtual
-    ~CommandObjectWatchpointDelete () {}
+    ~CommandObjectWatchpointDelete () override {}
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (!CheckTargetForWatchpointOperations(target, result))
             return false;
 
         Mutex::Locker locker;
         target->GetWatchpointList().GetListMutex(locker);
         
CommandObjectWatchpointIgnore (CommandInterpreter &interpreter) :
         m_options (interpreter)
     {
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back(arg);
     }
 
-    virtual
-    ~CommandObjectWatchpointIgnore () {}
+    ~CommandObjectWatchpointIgnore () override {}
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             m_ignore_count (0)
         {
         }
 
-        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 'i':
                 {
                     m_ignore_count = StringConvert::ToUInt32(option_arg, UINT32_MAX, 0);
                     if (m_ignore_count == UINT32_MAX)
                        error.SetErrorStringWithFormat ("invalid ignore count '%s'", option_arg);
                 }
                 break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_ignore_count = 0;
         }
 
         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.
 
         uint32_t m_ignore_count;
     };
 
 protected:
-    virtual bool
+    bool
     DoExecute (Args& command,
-             CommandReturnObject &result)
+             CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (!CheckTargetForWatchpointOperations(target, result))
             return false;
 
         Mutex::Locker locker;
         target->GetWatchpointList().GetListMutex(locker);
         
CommandObjectWatchpointModify (CommandInterpreter &interpreter) :
         m_options (interpreter)
     {
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back (arg);   
     }
 
-    virtual
-    ~CommandObjectWatchpointModify () {}
+    ~CommandObjectWatchpointModify () override {}
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
 
         CommandOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             m_condition (),
             m_condition_passed (false)
         {
         }
 
-        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 'c':
                     if (option_arg != NULL)
                         m_condition.assign (option_arg);
                     else
                         m_condition.clear();
                     m_condition_passed = true;
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_condition.clear();
             m_condition_passed = 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.
 
         std::string m_condition;
         bool m_condition_passed;
     };
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         if (!CheckTargetForWatchpointOperations(target, result))
             return false;
 
         Mutex::Locker locker;
         target->GetWatchpointList().GetListMutex(locker);
         
corresponding to the byte size of the data type."
         // Push the data for the only argument into the m_arguments vector.
         m_arguments.push_back (arg);
 
         // Absorb the '-w' and '-x' options into our option group.
         m_option_group.Append (&m_option_watchpoint, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Finalize();
     }
 
-    virtual
-    ~CommandObjectWatchpointSetVariable () {}
+    ~CommandObjectWatchpointSetVariable () override {}
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_option_group;
     }
 
 protected:
     static size_t GetVariableCallback (void *baton,
                                        const char *name,
                                        VariableList &variable_list)
     {
         Target *target = static_cast<Target *>(baton);
         if (target)
         {
             return target->GetImages().FindGlobalVariables (ConstString(name),
                                                             true,
                                                             UINT32_MAX,
                                                             variable_list);
         }
         return 0;
     }
     
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         StackFrame *frame = m_exe_ctx.GetFramePtr();
 
         // If no argument is present, issue an error message.  There's no way to set a watchpoint.
         if (command.GetArgumentCount() <= 0)
         {
             result.GetErrorStream().Printf("error: required argument missing; specify your program variable to watch for\n");
Watches write access for the 1-byte region pointed to by the address 'foo + 32')"
         m_arguments.push_back (arg);
 
         // Absorb the '-w' and '-x' options into our option group.
         m_option_group.Append (&m_option_watchpoint, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Finalize();
     }
 
 
-    virtual
-    ~CommandObjectWatchpointSetExpression () {}
+    ~CommandObjectWatchpointSetExpression () override {}
 
     // Overrides base class's behavior where WantsCompletion = !WantsRawCommandString.
-    virtual bool
-    WantsCompletion() { return true; }
+    bool
+    WantsCompletion() override { return true; }
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_option_group;
     }
 
 protected:
-    virtual bool
-    DoExecute (const char *raw_command, CommandReturnObject &result)
+    bool
+    DoExecute (const char *raw_command, CommandReturnObject &result) override
     {
         m_option_group.NotifyOptionParsingStarting(); // This is a raw command, so notify the option group
         
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         StackFrame *frame = m_exe_ctx.GetFramePtr();
 
         Args command(raw_command);
         const char *expr = NULL;
CommandObjectWatchpointSet (CommandInterpreter &interpreter) :
                                 "watchpoint set <subcommand> [<subcommand-options>]")
     {
         
         LoadSubCommand ("variable",   CommandObjectSP (new CommandObjectWatchpointSetVariable (interpreter)));
         LoadSubCommand ("expression", CommandObjectSP (new CommandObjectWatchpointSetExpression (interpreter)));
     }
 
 
-    virtual
-    ~CommandObjectWatchpointSet () {}
+    ~CommandObjectWatchpointSet () override {}
 
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectMultiwordWatchpoint
 //-------------------------------------------------------------------------
 #pragma mark MultiwordWatchpoint
 

source/Commands/CommandObjectWatchpointCommand.cpp

are no syntax errors may indicate that a function was declared but never called."
 
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (wp_id_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    virtual
-    ~CommandObjectWatchpointCommandAdd () {}
+    ~CommandObjectWatchpointCommandAdd () override {}
 
-    virtual Options *
-    GetOptions ()
+    Options *
+    GetOptions () override
     {
         return &m_options;
     }
 
-    virtual void
-    IOHandlerActivated (IOHandler &io_handler)
+    void
+    IOHandlerActivated (IOHandler &io_handler) override
     {
         StreamFileSP output_sp(io_handler.GetOutputStreamFile());
         if (output_sp)
         {
             output_sp->PutCString("Enter your debugger command(s).  Type 'DONE' to end.\n");
             output_sp->Flush();
         }
     }
     
     
-    virtual void
-    IOHandlerInputComplete (IOHandler &io_handler, std::string &line)
+    void
+    IOHandlerInputComplete (IOHandler &io_handler, std::string &line) override
     {
         io_handler.SetIsDone(true);
         
         // The WatchpointOptions object is owned by the watchpoint or watchpoint location
         WatchpointOptions *wp_options = (WatchpointOptions *) io_handler.GetUserData();
         if (wp_options)
         {
             std::unique_ptr<WatchpointOptions::CommandData> data_ap(new WatchpointOptions::CommandData());
public:
             m_use_script_language (false),
             m_script_language (eScriptLanguageNone),
             m_use_one_liner (false),
             m_one_liner(),
             m_function_name()
         {
         }
 
-        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 'o':
                 m_use_one_liner = true;
public:
                 break;
 
             default:
                 break;
             }
             return error;
         }
         void
-        OptionParsingStarting ()
+        OptionParsingStarting () override
         {
             m_use_commands = true;
             m_use_script_language = false;
             m_script_language = eScriptLanguageNone;
 
             m_use_one_liner = false;
             m_stop_on_error = true;
             m_one_liner.clear();
             m_function_name.clear();
         }
 
         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_use_commands;
         bool m_use_script_language;
         lldb::ScriptLanguage m_script_language;
 
         // Instance variables to hold the values for one_liner options.
         bool m_use_one_liner;
         std::string m_one_liner;
         bool m_stop_on_error;
         std::string m_function_name;
     };
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
 
         if (target == NULL)
         {
             result.AppendError ("There is not a current executable; there are no watchpoints to which to add commands");
             result.SetStatus (eReturnStatusFailed);
             return false;
CommandObjectWatchpointCommandDelete (CommandInterpreter &interpreter) :
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (wp_id_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
 
-    virtual
-    ~CommandObjectWatchpointCommandDelete () {}
+    ~CommandObjectWatchpointCommandDelete () override {}
 
 protected:
-    virtual bool
-    DoExecute (Args& command, CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
 
         if (target == NULL)
         {
             result.AppendError ("There is not a current executable; there are no watchpoints from which to delete commands");
             result.SetStatus (eReturnStatusFailed);
             return false;
CommandObjectWatchpointCommandList (CommandInterpreter &interpreter) :
 
         // There is only one variant this argument could be; put it into the argument entry.
         arg.push_back (wp_id_arg);
 
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg);
     }
 
-    virtual
-    ~CommandObjectWatchpointCommandList () {}
+    ~CommandObjectWatchpointCommandList () override {}
 
 protected:
-    virtual bool
-    DoExecute (Args& command,
-             CommandReturnObject &result)
+    bool
+    DoExecute (Args& command, CommandReturnObject &result) override
     {
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
 
         if (target == NULL)
         {
             result.AppendError ("There is not a current executable; there are no watchpoints for which to list commands");
             result.SetStatus (eReturnStatusFailed);
             return false;