[lldb-mi] Use 'override' on overridden virtual methods.

[brucem]

Summary

[lldb-mi] Use 'override' on overridden virtual methods.

[abidh]

Apart from one small change, looks good.

tools/lldb-mi/MICmdArgValBase.h

46

You missed this line.

tools/lldb-mi/MICmdArgValBase.h

 {
     // Methods:
   public:
     /* ctor */ CMICmdArgValBase(void);
     /* ctor */ CMICmdArgValBase(const CMIUtilString &vrArgName, const bool vbMandatory, const bool vbHandleByCmd);
 
     // Overrideable:
   public:
     /* dtor */ virtual ~CMICmdArgValBase(void);
 
     // Overridden:
   public:
     // From CMICmdArgSet::IArg
-    virtual bool GetFound(void) const;
-    virtual bool GetIsHandledByCmd(void) const;
-    virtual bool GetIsMandatory(void) const;
-    virtual bool GetIsMissingOptions(void) const;
-    virtual const CMIUtilString &GetName(void) const;
-    virtual bool GetValid(void) const;
-    virtual bool Validate(CMICmdArgContext &vwArgContext);
+    bool GetFound(void) const override;
+    bool GetIsHandledByCmd(void) const override;
+    bool GetIsMandatory(void) const override;
+    bool GetIsMissingOptions(void) const override;
+    const CMIUtilString &GetName(void) const override;
+    bool GetValid(void) const override;
+    bool Validate(CMICmdArgContext &vwArgContext) override;
 
     // Attributes:
   protected:
     bool m_bFound;     // True = yes found in arguments options text, false = not found
     bool m_bValid;     // True = yes argument parsed and valid, false = not valid
     bool m_bMandatory; // True = yes arg must be present, false = optional argument
     CMIUtilString m_strArgName;
     bool m_bHandled;          // True = Command processes *this option, false = not handled

tools/lldb-mi/MICmdArgValConsume.h

public:
     /* ctor */ CMICmdArgValConsume(void);
     /* ctor */ CMICmdArgValConsume(const CMIUtilString &vrArgName, const bool vbMandatory);
     //
     bool IsOk(void) const;
 
     // Overridden:
   public:
     // From CMICmdArgValBase
-    /* dtor */ virtual ~CMICmdArgValConsume(void);
+    /* dtor */ ~CMICmdArgValConsume(void) override;
     // From CMICmdArgSet::IArg
-    virtual bool Validate(CMICmdArgContext &vwArgContext);
+    bool Validate(CMICmdArgContext &vwArgContext) override;
 };

tools/lldb-mi/MICmdArgValFile.h

public:
     /* ctor */ CMICmdArgValFile(const CMIUtilString &vrArgName, const bool vbMandatory, const bool vbHandleByCmd);
     //
     bool IsFilePath(const CMIUtilString &vrFileNamePath) const;
     CMIUtilString GetFileNamePath(const CMIUtilString &vrTxt) const;
 
     // Overridden:
   public:
     // From CMICmdArgValBase
-    /* dtor */ virtual ~CMICmdArgValFile(void);
+    /* dtor */ ~CMICmdArgValFile(void) override;
     // From CMICmdArgSet::IArg
-    virtual bool Validate(CMICmdArgContext &vwArgContext);
+    bool Validate(CMICmdArgContext &vwArgContext) override;
 
     // Methods:
   private:
     bool IsValidChars(const CMIUtilString &vrText) const;
 };

tools/lldb-mi/MICmdArgValListBase.h

public:
     /* ctor */ CMICmdArgValListBase(void);
     /* ctor */ CMICmdArgValListBase(const CMIUtilString &vrArgName, const bool vbMandatory, const bool vbHandleByCmd);
     /* ctor */ CMICmdArgValListBase(const CMIUtilString &vrArgName, const bool vbMandatory, const bool vbHandleByCmd,
                                     const ArgValType_e veType);
 
     // Overridden:
   public:
     // From CMICmdArgValBase
-    /* dtor */ virtual ~CMICmdArgValListBase(void);
+    /* dtor */ ~CMICmdArgValListBase(void) override;
 
     // Methods:
   protected:
     bool IsExpectedCorrectType(const CMIUtilString &vrTxt, const ArgValType_e veType) const;
     CMICmdArgValBase *CreationObj(const CMIUtilString &vrTxt, const ArgValType_e veType) const;
 
     // Attributes:
   protected:
     ArgValType_e m_eArgType;
 
     // Methods:
   private:
     void Destroy(void);
 };

tools/lldb-mi/MICmdArgValListOfN.h

/* ctor */ CMICmdArgValListOfN(const CMIUtilString &vrArgName, const bool vbMandatory, const bool vbHandleByCmd,
                                    const ArgValType_e veType);
     //
     const VecArgObjPtr_t &GetExpectedOptions(void) const;
     template <class T1, typename T2> bool GetExpectedOption(T2 &vrwValue, const VecArgObjPtr_t::size_type vnAt = 0) const;
 
     // Overridden:
   public:
     // From CMICmdArgValBase
-    /* dtor */ virtual ~CMICmdArgValListOfN(void);
+    /* dtor */ ~CMICmdArgValListOfN(void) override;
     // From CMICmdArgSet::IArg
-    virtual bool Validate(CMICmdArgContext &vArgContext);
+    bool Validate(CMICmdArgContext &vArgContext) override;
 
     // Methods:
   private:
     bool IsListOfN(const CMIUtilString &vrTxt) const;
     bool CreateList(const CMIUtilString &vrTxt);
 };
 
 //++ ------------------------------------------------------------------------------------

tools/lldb-mi/MICmdArgValNumber.h

public:
     /* ctor */ CMICmdArgValNumber(const CMIUtilString &vrArgName, const bool vbMandatory, const bool vbHandleByCmd,
                                   const MIuint vnNumberFormatMask = eArgValNumberFormat_Decimal);
     //
     bool IsArgNumber(const CMIUtilString &vrTxt) const;
 
     // Overridden:
   public:
     // From CMICmdArgValBase
-    /* dtor */ virtual ~CMICmdArgValNumber(void);
+    /* dtor */ ~CMICmdArgValNumber(void) override;
     // From CMICmdArgSet::IArg
-    virtual bool Validate(CMICmdArgContext &vwArgContext);
+    bool Validate(CMICmdArgContext &vwArgContext) override;
 
     // Methods:
   private:
     bool ExtractNumber(const CMIUtilString &vrTxt);
     MIint64 GetNumber(void) const;
 
     // Attributes:
   private:
     MIuint m_nNumberFormatMask;
     MIint64 m_nNumber;
 };

tools/lldb-mi/MICmdArgValOptionLong.h

public:
     //
     bool IsArgLongOption(const CMIUtilString &vrTxt) const;
     const VecArgObjPtr_t &GetExpectedOptions(void) const;
     template <class T1, typename T2> bool GetExpectedOption(T2 &vrwValue) const;
 
     // Overridden:
   public:
     // From CMICmdArgValBase
-    /* dtor */ virtual ~CMICmdArgValOptionLong(void);
+    /* dtor */ ~CMICmdArgValOptionLong(void) override;
     // From CMICmdArgSet::IArg
-    virtual bool Validate(CMICmdArgContext &vArgContext);
+    bool Validate(CMICmdArgContext &vArgContext) override;
 
     // Methods:
   protected:
     bool ExtractExpectedOptions(CMICmdArgContext &vrwTxt, const MIuint nArgIndex);
 
     // Overrideable:
   protected:
     virtual bool IsArgOptionCorrect(const CMIUtilString &vrTxt) const;

tools/lldb-mi/MICmdArgValOptionShort.h

public:
     /* ctor */ CMICmdArgValOptionShort(const CMIUtilString &vrArgName, const bool vbMandatory, const bool vbHandleByCmd,
                                        const ArgValType_e veType, const MIuint vnExpectingNOptions);
     //
     bool IsArgShortOption(const CMIUtilString &vrTxt) const;
 
     // Overridden:
   public:
     // From CMICmdArgValBase
-    /* dtor */ virtual ~CMICmdArgValOptionShort(void);
+    /* dtor */ ~CMICmdArgValOptionShort(void) override;
 
     // Overridden:
   private:
     // From CMICmdArgValOptionLong
-    virtual bool IsArgOptionCorrect(const CMIUtilString &vrTxt) const;
-    virtual bool ArgNameMatch(const CMIUtilString &vrTxt) const;
+    bool IsArgOptionCorrect(const CMIUtilString &vrTxt) const override;
+    bool ArgNameMatch(const CMIUtilString &vrTxt) const override;
 };

tools/lldb-mi/MICmdArgValPrintValues.h

public:
     /* ctor */ CMICmdArgValPrintValues(void);
     /* ctor */ CMICmdArgValPrintValues(const CMIUtilString &vrArgName, const bool vbMandatory, const bool vbHandleByCmd);
     //
     bool IsArgPrintValues(const CMIUtilString &vrTxt) const;
 
     // Overridden:
   public:
     // From CMICmdArgValBase
-    /* dtor */ virtual ~CMICmdArgValPrintValues(void);
+    /* dtor */ ~CMICmdArgValPrintValues(void) override;
     // From CMICmdArgSet::IArg
-    virtual bool Validate(CMICmdArgContext &vArgContext);
+    bool Validate(CMICmdArgContext &vArgContext) override;
 
     // Methods:
   private:
     bool ExtractPrintValues(const CMIUtilString &vrTxt);
     MIuint GetPrintValues(void) const;
 
     // Attributes:
   private:
     MIuint m_nPrintValues;
 };

tools/lldb-mi/MICmdArgValString.h

public:
     /* ctor */ CMICmdArgValString(const CMIUtilString &vrArgName, const bool vbMandatory, const bool vbHandleByCmd,
                                   const bool vbHandleQuotes = false, const bool vbAcceptNumbers = false);
     //
     bool IsStringArg(const CMIUtilString &vrTxt) const;
 
     // Overridden:
   public:
     // From CMICmdArgValBase
-    /* dtor */ virtual ~CMICmdArgValString(void);
+    /* dtor */ ~CMICmdArgValString(void) override;
     // From CMICmdArgSet::IArg
-    virtual bool Validate(CMICmdArgContext &vrwArgContext);
+    bool Validate(CMICmdArgContext &vrwArgContext) override;
 
     // Methods:
   private:
     bool ValidateSingleText(CMICmdArgContext &vrwArgContext);
     bool ValidateQuotedText(CMICmdArgContext &vrwArgContext);
     bool ValidateQuotedTextEmbedded(CMICmdArgContext &vrwArgContext);
     bool ValidateQuotedQuotedTextEmbedded(CMICmdArgContext &vrwArgContext);
     bool IsStringArgSingleText(const CMIUtilString &vrTxt) const;

tools/lldb-mi/MICmdArgValThreadGrp.h

public:
     /* ctor */ CMICmdArgValThreadGrp(void);
     /* ctor */ CMICmdArgValThreadGrp(const CMIUtilString &vrArgName, const bool vbMandatory, const bool vbHandleByCmd);
     //
     bool IsArgThreadGrp(const CMIUtilString &vrTxt) const;
 
     // Overridden:
   public:
     // From CMICmdArgValBase
-    /* dtor */ virtual ~CMICmdArgValThreadGrp(void);
+    /* dtor */ ~CMICmdArgValThreadGrp(void) override;
     // From CMICmdArgSet::IArg
-    virtual bool Validate(CMICmdArgContext &vArgContext);
+    bool Validate(CMICmdArgContext &vArgContext) override;
 
     // Methods:
   private:
     bool ExtractNumber(const CMIUtilString &vrTxt);
     MIuint GetNumber(void) const;
 
     // Attributes:
   private:
     MIuint m_nThreadGrp;
 };

tools/lldb-mi/MICmdCmd.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdEnablePrettyPrinting(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdEnablePrettyPrinting(void);
+    /* dtor */ ~CMICmdCmdEnablePrettyPrinting(void) override;
 };
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "source".
 // Gotchas: None.
 // Authors: Illya Rudkin 05/03/2014.
 // Changes: None.
 //--
 class CMICmdCmdSource : public CMICmdBase
 {
     // Statics:
   public:
     // Required by the CMICmdFactory when registering *this command
     static CMICmdBase *CreateSelf(void);
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdSource(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdSource(void);
+    /* dtor */ ~CMICmdCmdSource(void) override;
 };

tools/lldb-mi/MICmdCmdBreak.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdBreakInsert(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdBreakInsert(void);
+    /* dtor */ ~CMICmdCmdBreakInsert(void) override;
 
     // Enumerations:
   private:
     //++ ===================================================================
     // Details: The type of break point give in the MI command text.
     //--
     enum BreakPoint_e
     {
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdBreakDelete(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdBreakDelete(void);
+    /* dtor */ ~CMICmdCmdBreakDelete(void) override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgNamedBrkPt;
     const CMIUtilString m_constStrArgNamedThreadGrp; // Not specified in MI spec but Eclipse gives this option
 };
 
 //++ ============================================================================
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdBreakDisable(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdBreakDisable(void);
+    /* dtor */ ~CMICmdCmdBreakDisable(void) override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgNamedThreadGrp; // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgNamedBrkPt;
     bool m_bBrkPtDisabledOk;
     MIuint m_nBrkPtId;
 };
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdBreakEnable(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdBreakEnable(void);
+    /* dtor */ ~CMICmdCmdBreakEnable(void) override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgNamedThreadGrp; // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgNamedBrkPt;
     bool m_bBrkPtEnabledOk;
     MIuint m_nBrkPtId;
 };
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdBreakAfter(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdBreakAfter(void);
+    /* dtor */ ~CMICmdCmdBreakAfter(void) override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgNamedThreadGrp; // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgNamedNumber;
     const CMIUtilString m_constStrArgNamedCount;
     MIuint m_nBrkPtId;
     MIuint m_nBrkPtCount;
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdBreakCondition(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdBreakCondition(void);
+    /* dtor */ ~CMICmdCmdBreakCondition(void) override;
 
     // Methods:
   private:
     CMIUtilString GetRestOfExpressionNotSurroundedInQuotes(void);
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgNamedThreadGrp; // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgNamedNumber;
     const CMIUtilString m_constStrArgNamedExpr;
     const CMIUtilString m_constStrArgNamedExprNoQuotes; // Not specified in MI spec, we need to handle expressions not surrounded by quotes
     MIuint m_nBrkPtId;
     CMIUtilString m_strBrkPtExpr;
 };

tools/lldb-mi/MICmdCmdData.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdDataEvaluateExpression(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdDataEvaluateExpression(void);
+    /* dtor */ ~CMICmdCmdDataEvaluateExpression(void) override;
 
     // Methods:
   private:
     bool HaveInvalidCharacterInExpression(const CMIUtilString &vrExpr, char &vrwInvalidChar);
 
     // Attributes:
   private:
     bool m_bExpressionValid;     // True = yes is valid, false = not valid
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdDataDisassemble(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdDataDisassemble(void);
+    /* dtor */ ~CMICmdCmdDataDisassemble(void) override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgThread;    // Not specified in MI spec but Eclipse gives this option. Not handled by command.
     const CMIUtilString m_constStrArgAddrStart; // MI spec non mandatory, *this command mandatory
     const CMIUtilString m_constStrArgAddrEnd;   // MI spec non mandatory, *this command mandatory
     const CMIUtilString m_constStrArgConsume;
     const CMIUtilString m_constStrArgMode;
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdDataReadMemoryBytes(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdDataReadMemoryBytes(void);
+    /* dtor */ ~CMICmdCmdDataReadMemoryBytes(void) override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgThread; // Not in the MI spec but implemented by GDB.
     const CMIUtilString m_constStrArgFrame; // Not in the MI spec but implemented by GDB.
     const CMIUtilString m_constStrArgByteOffset;
     const CMIUtilString m_constStrArgAddrExpr;
     const CMIUtilString m_constStrArgNumBytes;
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdDataReadMemory(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdDataReadMemory(void);
+    /* dtor */ ~CMICmdCmdDataReadMemory(void) override;
 };
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "data-list-register-names".
 // Gotchas: None.
 // Authors: Illya Rudkin 21/05/2014.
 // Changes: None.
 //--
 class CMICmdCmdDataListRegisterNames : public CMICmdBase
 {
     // Statics:
   public:
     // Required by the CMICmdFactory when registering *this command
     static CMICmdBase *CreateSelf(void);
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdDataListRegisterNames(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdDataListRegisterNames(void);
+    /* dtor */ ~CMICmdCmdDataListRegisterNames(void) override;
 
     // Methods:
   private:
     lldb::SBValue GetRegister(const MIuint vRegisterIndex) const;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgThreadGroup; // Not specified in MI spec but Eclipse gives this option
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdDataListRegisterValues(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdDataListRegisterValues(void);
+    /* dtor */ ~CMICmdCmdDataListRegisterValues(void) override;
 
     // Methods:
   private:
     lldb::SBValue GetRegister(const MIuint vRegisterIndex) const;
     bool AddToOutput(const MIuint vnIndex, const lldb::SBValue &vrValue, CMICmnLLDBDebugSessionInfoVarObj::varFormat_e veVarFormat);
 
     // Attributes:
   private:
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdDataListRegisterChanged(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdDataListRegisterChanged(void);
+    /* dtor */ ~CMICmdCmdDataListRegisterChanged(void) override;
 };
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "data-read-memory-bytes".
 // Gotchas: None.
 // Authors: Illya Rudkin 30/05/2014.
 // Changes: None.
 //--
 class CMICmdCmdDataWriteMemoryBytes : public CMICmdBase
 {
     // Statics:
   public:
     // Required by the CMICmdFactory when registering *this command
     static CMICmdBase *CreateSelf(void);
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdDataWriteMemoryBytes(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdDataWriteMemoryBytes(void);
+    /* dtor */ ~CMICmdCmdDataWriteMemoryBytes(void) override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgThread; // Not specified in MI spec but Eclipse gives this option. Not handled by command.
     const CMIUtilString m_constStrArgAddr;
     const CMIUtilString m_constStrArgContents;
     const CMIUtilString m_constStrArgCount;
     CMIUtilString m_strContents;
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdDataWriteMemory(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdDataWriteMemory(void);
+    /* dtor */ ~CMICmdCmdDataWriteMemory(void) override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgThread;   // Not specified in MI spec but Eclipse gives this option. Not handled by command.
     const CMIUtilString m_constStrArgOffset;   // Not specified in MI spec but Eclipse gives this option.
     const CMIUtilString m_constStrArgAddr;     // Not specified in MI spec but Eclipse gives this option.
     const CMIUtilString m_constStrArgD;        // Not specified in MI spec but Eclipse gives this option.
     const CMIUtilString m_constStrArgNumber;   // Not specified in MI spec but Eclipse gives this option.
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdDataInfoLine(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdDataInfoLine(void);
+    /* dtor */ ~CMICmdCmdDataInfoLine(void) override;
 
     // Attributes:
   private:
     lldb::SBCommandReturnObject m_lldbResult;
     const CMIUtilString m_constStrArgLocation;
 };

tools/lldb-mi/MICmdCmdEnviro.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdEnvironmentCd(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdEnvironmentCd(void);
+    /* dtor */ ~CMICmdCmdEnvironmentCd(void) override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgNamePathDir;
 };

tools/lldb-mi/MICmdCmdExec.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdExecRun(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdExecRun(void);
+    /* dtor */ ~CMICmdCmdExecRun(void) override;
 
     // Attributes:
   private:
     lldb::SBCommandReturnObject m_lldbResult;
 };
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdExecContinue(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdExecContinue(void);
+    /* dtor */ ~CMICmdCmdExecContinue(void) override;
 
     // Attributes:
   private:
     lldb::SBCommandReturnObject m_lldbResult;
 };
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdExecNext(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdExecNext(void);
+    /* dtor */ ~CMICmdCmdExecNext(void) override;
 
     // Attributes:
   private:
     lldb::SBCommandReturnObject m_lldbResult;
     const CMIUtilString m_constStrArgThread; // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgNumber; // Not specified in MI spec but Eclipse gives this option
 };
 
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdExecStep(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdExecStep(void);
+    /* dtor */ ~CMICmdCmdExecStep(void) override;
 
     // Attributes:
   private:
     lldb::SBCommandReturnObject m_lldbResult;
     const CMIUtilString m_constStrArgThread; // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgNumber; // Not specified in MI spec but Eclipse gives this option
 };
 
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdExecNextInstruction(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdExecNextInstruction(void);
+    /* dtor */ ~CMICmdCmdExecNextInstruction(void) override;
 
     // Attributes:
   private:
     lldb::SBCommandReturnObject m_lldbResult;
     const CMIUtilString m_constStrArgThread; // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgNumber; // Not specified in MI spec but Eclipse gives this option
 };
 
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdExecStepInstruction(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdExecStepInstruction(void);
+    /* dtor */ ~CMICmdCmdExecStepInstruction(void) override;
 
     // Attributes:
   private:
     lldb::SBCommandReturnObject m_lldbResult;
     const CMIUtilString m_constStrArgThread; // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgNumber; // Not specified in MI spec but Eclipse gives this option
 };
 
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdExecFinish(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdExecFinish(void);
+    /* dtor */ ~CMICmdCmdExecFinish(void) override;
 
     // Attributes:
   private:
     lldb::SBCommandReturnObject m_lldbResult;
     const CMIUtilString m_constStrArgThread; // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgFrame;  // Not specified in MI spec but Eclipse gives this option
 };
 
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdExecInterrupt(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdExecInterrupt(void);
+    /* dtor */ ~CMICmdCmdExecInterrupt(void) override;
 
     // Attributes:
   private:
     lldb::SBCommandReturnObject m_lldbResult;
 };
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdExecArguments(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdExecArguments(void);
+    /* dtor */ ~CMICmdCmdExecArguments(void) override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgArguments;
 };
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "exec-abort".
 //--
 class CMICmdCmdExecAbort : public CMICmdBase
 {
     // Statics:
   public:
     // Required by the CMICmdFactory when registering *this command
     static CMICmdBase *CreateSelf(void);
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdExecAbort(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdExecAbort(void);
+    /* dtor */ ~CMICmdCmdExecAbort(void) override;
 };

tools/lldb-mi/MICmdCmdFile.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdFileExecAndSymbols(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdFileExecAndSymbols(void);
-    virtual bool GetExitAppOnCommandFailure(void) const;
+    /* dtor */ ~CMICmdCmdFileExecAndSymbols(void) override;
+    bool GetExitAppOnCommandFailure(void) const override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgNameFile;
     const CMIUtilString
         m_constStrArgThreadGrp; // Not handled by *this command. Not specified in MI spec but Eclipse gives this option sometimes
     const CMIUtilString m_constStrArgNamedPlatformName; // Added to support iOS platform selection
     const CMIUtilString m_constStrArgNamedRemotePath; // Added to support iOS device remote file location
 };

tools/lldb-mi/MICmdCmdGdbInfo.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdGdbInfo(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdGdbInfo(void);
+    /* dtor */ ~CMICmdCmdGdbInfo(void) override;
 
     // Typedefs:
   private:
     typedef bool (CMICmdCmdGdbInfo::*FnPrintPtr)();
     typedef std::map<CMIUtilString, FnPrintPtr> MapPrintFnNameToPrintFn_t;
 
     // Methods:
   private:

tools/lldb-mi/MICmdCmdGdbSet.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdGdbSet(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdGdbSet(void);
+    /* dtor */ ~CMICmdCmdGdbSet(void) override;
 
     // Typedefs:
   private:
     typedef bool (CMICmdCmdGdbSet::*FnGdbOptionPtr)(const CMIUtilString::VecString_t &vrWords);
     typedef std::map<CMIUtilString, FnGdbOptionPtr> MapGdbOptionNameToFnGdbOptionPtr_t;
 
     // Methods:
   private:

tools/lldb-mi/MICmdCmdGdbShow.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdGdbShow(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdGdbShow(void);
+    /* dtor */ ~CMICmdCmdGdbShow(void) override;
 
     // Typedefs:
   private:
     typedef bool (CMICmdCmdGdbShow::*FnGdbOptionPtr)(const CMIUtilString::VecString_t &vrWords);
     typedef std::map<CMIUtilString, FnGdbOptionPtr> MapGdbOptionNameToFnGdbOptionPtr_t;
 
     // Methods:
   private:

tools/lldb-mi/MICmdCmdGdbThread.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdGdbThread(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdGdbThread(void);
+    /* dtor */ ~CMICmdCmdGdbThread(void) override;
 };

tools/lldb-mi/MICmdCmdMiscellanous.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdGdbExit(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdGdbExit(void);
+    /* dtor */ ~CMICmdCmdGdbExit(void) override;
 };
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "list-thread-groups".
 //          This command does not follow the MI documentation exactly.
 //          http://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI-Miscellaneous-Commands.html#GDB_002fMI-Miscellaneous-Commands
 // Gotchas: None.
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdListThreadGroups(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdListThreadGroups(void);
+    /* dtor */ ~CMICmdCmdListThreadGroups(void) override;
 
     // Typedefs:
   private:
     typedef std::vector<CMICmnMIValueTuple> VecMIValueTuple_t;
 
     // Attributes:
   private:
     bool m_bIsI1;           // True = Yes command argument equal "i1", false = no match
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdInterpreterExec(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdInterpreterExec(void);
+    /* dtor */ ~CMICmdCmdInterpreterExec(void) override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgNamedInterpreter;
     const CMIUtilString m_constStrArgNamedCommand;
     lldb::SBCommandReturnObject m_lldbResult;
 };
 
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdInferiorTtySet(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdInferiorTtySet(void);
+    /* dtor */ ~CMICmdCmdInferiorTtySet(void) override;
 };

tools/lldb-mi/MICmdCmdStack.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdStackInfoDepth(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdStackInfoDepth(void);
+    /* dtor */ ~CMICmdCmdStackInfoDepth(void) override;
 
     // Attributes:
   private:
     MIuint m_nThreadFrames;
     const CMIUtilString m_constStrArgThread;   // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgMaxDepth; // Not handled by *this command
 };
 
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdStackInfoFrame(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdStackInfoFrame(void);
+    /* dtor */ ~CMICmdCmdStackInfoFrame(void) override;
 
     // Attributes:
   private:
     CMICmnMIValueTuple m_miValueTuple;
 };
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdStackListFrames(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdStackListFrames(void);
+    /* dtor */ ~CMICmdCmdStackListFrames(void) override;
 
     // Typedefs:
   private:
     typedef std::vector<CMICmnMIValueResult> VecMIValueResult_t;
 
     // Attributes:
   private:
     MIuint m_nThreadFrames;
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdStackListArguments(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdStackListArguments(void);
+    /* dtor */ ~CMICmdCmdStackListArguments(void) override;
 
     // Attributes:
   private:
     bool m_bThreadInvalid; // True = yes invalid thread, false = thread object valid
     CMICmnMIValueList m_miValueList;
     const CMIUtilString m_constStrArgThread;      // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgPrintValues;
     const CMIUtilString m_constStrArgFrameLow;
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdStackListLocals(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdStackListLocals(void);
+    /* dtor */ ~CMICmdCmdStackListLocals(void) override;
 
     // Attributes:
   private:
     bool m_bThreadInvalid; // True = yes invalid thread, false = thread object valid
     CMICmnMIValueList m_miValueList;
     const CMIUtilString m_constStrArgThread;      // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgFrame;       // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgPrintValues;
public:
     
     // Methods:
 public:
     /* ctor */ CMICmdCmdStackListVariables(void);
     
     // Overridden:
 public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdStackListVariables(void);
+    /* dtor */ ~CMICmdCmdStackListVariables(void) override;
     
     // Attributes
 private:
     bool m_bThreadInvalid; // True = yes invalid thread, false = thread object valid
     CMICmnMIValueList m_miValueList;
     const CMIUtilString m_constStrArgThread;
     const CMIUtilString m_constStrArgFrame;
     const CMIUtilString m_constStrArgPrintValues;
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdStackSelectFrame(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdStackSelectFrame(void);
+    /* dtor */ ~CMICmdCmdStackSelectFrame(void) override;
 
     // Attributes:
   private:
     bool m_bFrameInvalid; // True = yes invalid frame, false = ok
     const CMIUtilString m_constStrArgFrame;
 };

tools/lldb-mi/MICmdCmdSupportInfo.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdSupportInfoMiCmdQuery(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdSupportInfoMiCmdQuery(void);
+    /* dtor */ ~CMICmdCmdSupportInfoMiCmdQuery(void) override;
 
     // Attributes:
   private:
     bool m_bCmdFound; // True = query for the command in command factory found, false = not found not recognised
     const CMIUtilString m_constStrArgCmdName;
 };

tools/lldb-mi/MICmdCmdSupportList.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdSupportListFeatures(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdSupportListFeatures(void);
+    /* dtor */ ~CMICmdCmdSupportListFeatures(void) override;
 };

tools/lldb-mi/MICmdCmdSymbol.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdSymbolListLines(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdSymbolListLines(void);
+    /* dtor */ ~CMICmdCmdSymbolListLines(void) override;
 
     // Attributes:
   private:
     lldb::SBCommandReturnObject m_lldbResult;
     const CMIUtilString m_constStrArgNameFile;
 };

tools/lldb-mi/MICmdCmdTarget.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdTargetSelect(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdTargetSelect(void);
+    /* dtor */ ~CMICmdCmdTargetSelect(void) override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgNamedType;
     const CMIUtilString m_constStrArgNamedParameters;
 };
 
 //++ ============================================================================
public:
     
     // Methods:
 public:
     /* ctor */ CMICmdCmdTargetAttach(void);
     
     // Overridden:
 public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdTargetAttach(void);
+    /* dtor */ ~CMICmdCmdTargetAttach(void) override;
     
     // Attributes:
 private:
     const CMIUtilString m_constStrArgPid;
     const CMIUtilString m_constStrArgNamedFile;
     const CMIUtilString m_constStrArgWaitFor;
 };
 
public:
     
     // Methods:
 public:
     /* ctor */ CMICmdCmdTargetDetach(void);
     
     // Overridden:
 public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdTargetDetach(void);
+    /* dtor */ ~CMICmdCmdTargetDetach(void) override;
 };
 

tools/lldb-mi/MICmdCmdThread.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdThreadInfo(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdThreadInfo(void);
+    /* dtor */ ~CMICmdCmdThreadInfo(void) override;
 
     // Typedefs:
   private:
     typedef std::vector<CMICmnMIValueTuple> VecMIValueTuple_t;
 
     // Attributes:
   private:
     CMICmnMIValueTuple m_miValueTupleThread;
     bool m_bSingleThread;  // True = yes single thread, false = multiple threads
     bool m_bThreadInvalid; // True = invalid, false = ok
     VecMIValueTuple_t m_vecMIValueTuple;
     const CMIUtilString m_constStrArgNamedThreadId;
 };

tools/lldb-mi/MICmdCmdTrace.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdTraceStatus(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdTraceStatus(void);
+    /* dtor */ ~CMICmdCmdTraceStatus(void) override;
 };

tools/lldb-mi/MICmdCmdVar.h

public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdVarCreate(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
 
     // Overridden:
   public:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdVarCreate(void);
+    /* dtor */ ~CMICmdCmdVarCreate(void) override;
 
     // Methods:
   private:
     void CompleteSBValue(lldb::SBValue &vrwValue);
 
     // Attribute:
   private:
     CMIUtilString m_strVarName;
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdVarUpdate(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
 
     // Overridden:
   public:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdVarUpdate(void);
+    /* dtor */ ~CMICmdCmdVarUpdate(void) override;
 
     // Methods:
   private:
     bool ExamineSBValueForChange(lldb::SBValue &vrwValue, bool &vrwbChanged);
     bool MIFormResponse(const CMIUtilString &vrStrVarName, const char *const vpValue, const CMIUtilString &vrStrScope);
 
     // Attribute:
   private:
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdVarDelete(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdVarDelete(void);
+    /* dtor */ ~CMICmdCmdVarDelete(void) override;
 
     // Attribute:
   private:
     const CMIUtilString m_constStrArgName;
 };
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdVarAssign(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdVarAssign(void);
+    /* dtor */ ~CMICmdCmdVarAssign(void) override;
 
     // Attributes:
   private:
     bool m_bOk; // True = success, false = failure
     CMIUtilString m_varObjName;
     const CMIUtilString m_constStrArgName;
     const CMIUtilString m_constStrArgExpression;
 };
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdVarSetFormat(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdVarSetFormat(void);
+    /* dtor */ ~CMICmdCmdVarSetFormat(void) override;
 
     // Attributes:
   private:
     CMIUtilString m_varObjName;
     const CMIUtilString m_constStrArgName;
     const CMIUtilString m_constStrArgFormatSpec;
 };
 
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdVarListChildren(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdVarListChildren(void);
+    /* dtor */ ~CMICmdCmdVarListChildren(void) override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgPrintValues;
     const CMIUtilString m_constStrArgName;
     const CMIUtilString m_constStrArgFrom;
     const CMIUtilString m_constStrArgTo;
     bool m_bValueValid; // True = yes SBValue object is valid, false = not valid
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdVarEvaluateExpression(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdVarEvaluateExpression(void);
+    /* dtor */ ~CMICmdCmdVarEvaluateExpression(void) override;
 
     // Attributes:
   private:
     bool m_bValueValid; // True = yes SBValue object is valid, false = not valid
     CMIUtilString m_varObjName;
     const CMIUtilString m_constStrArgFormatSpec; // Not handled by *this command
     const CMIUtilString m_constStrArgName;
 };
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdVarInfoPathExpression(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdVarInfoPathExpression(void);
+    /* dtor */ ~CMICmdCmdVarInfoPathExpression(void) override;
 
     // Attributes:
   private:
     bool m_bValueValid; // True = yes SBValue object is valid, false = not valid
     CMIUtilString m_strPathExpression;
     const CMIUtilString m_constStrArgName;
 };
 
public:
 
     // Methods:
   public:
     /* ctor */ CMICmdCmdVarShowAttributes(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
-    virtual bool Execute(void);
-    virtual bool Acknowledge(void);
-    virtual bool ParseArgs(void);
+    bool Execute(void) override;
+    bool Acknowledge(void) override;
+    bool ParseArgs(void) override;
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdCmdVarShowAttributes(void);
+    /* dtor */ ~CMICmdCmdVarShowAttributes(void) override;
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgName;
 };

tools/lldb-mi/MICmdFactory.h

class ICmd
         // virtual CMICmdBase *         CreateSelf( void ) = 0;             // Not possible as require a static creator
         // function in the command class, here for awareness
 
         /* dtor */ virtual ~ICmd(void){};
     };
 
     // Methods:
   public:
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
     bool CmdRegister(const CMIUtilString &vMiCmd, CmdCreatorFnPtr vCmdCreateFn);
     bool CmdCreate(const CMIUtilString &vMiCmd, const SMICmdData &vCmdData, CMICmdBase *&vpNewCmd);
     bool CmdExist(const CMIUtilString &vMiCmd) const;
 
     // Methods:
   private:
     /* ctor */ CMICmdFactory(void);
     /* ctor */ CMICmdFactory(const CMICmdFactory &);
     void operator=(const CMICmdFactory &);
 
     bool HaveAlready(const CMIUtilString &vMiCmd) const;
     bool IsValid(const CMIUtilString &vMiCmd) const;
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdFactory(void);
+    /* dtor */ ~CMICmdFactory(void) override;
 
     // Typedefs:
   private:
     typedef std::map<CMIUtilString, CmdCreatorFnPtr> MapMiCmdToCmdCreatorFn_t;
     typedef std::pair<CMIUtilString, CmdCreatorFnPtr> MapPairMiCmdToCmdCreatorFn_t;
 
     // Attributes:
   private:
     MapMiCmdToCmdCreatorFn_t m_mapMiCmdToCmdCreatorFn;
 };

tools/lldb-mi/MICmdInterpreter.h

 class CMICmdInterpreter : public CMICmnBase, public MI::ISingleton<CMICmdInterpreter>
 {
     friend MI::ISingleton<CMICmdInterpreter>;
 
     // Methods:
   public:
     // Methods:
   public:
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
     bool ValidateIsMi(const CMIUtilString &vTextLine, bool &vwbYesValid, bool &vwbCmdNotInCmdFactor, SMICmdData &rwCmdData);
 
     // Methods:
   private:
     /* ctor */ CMICmdInterpreter(void);
     /* ctor */ CMICmdInterpreter(const CMICmdInterpreter &);
     void operator=(const CMICmdInterpreter &);
 
     bool HasCmdFactoryGotMiCmd(const SMICmdData &vCmdData) const;
     bool MiHasCmdTokenEndingHyphen(const CMIUtilString &vTextLine);
     bool MiHasCmdTokenEndingAlpha(const CMIUtilString &vTextLine);
     bool MiHasCmd(const CMIUtilString &vTextLine);
     bool MiHasCmdTokenPresent(const CMIUtilString &vTextLine);
     const SMICmdData &MiGetCmdData() const;
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdInterpreter(void);
+    /* dtor */ ~CMICmdInterpreter(void) override;
 
     // Attributes:
   private:
     SMICmdData m_miCmdData; // Filled in on each new line being interpreted
     CMICmdFactory &m_rCmdFactory;
 };

tools/lldb-mi/MICmdInvoker.h

class ICmd
         virtual const CMIUtilString &GetMIResultRecordExtra(void) const = 0;
         virtual bool HasMIResultRecordExtra(void) const = 0;
 
         /* dtor */ virtual ~ICmd(void){};
     };
 
     // Methods:
   public:
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
     bool CmdExecute(CMICmdBase &vCmd);
     bool CmdExecuteFinished(CMICmdBase &vCmd);
 
     // Typedefs:
   private:
     typedef std::map<MIuint, CMICmdBase *> MapCmdIdToCmd_t;
     typedef std::pair<MIuint, CMICmdBase *> MapPairCmdIdToCmd_t;
 
     // Methods:
   private:
     /* ctor */ CMICmdInvoker(void);
     /* ctor */ CMICmdInvoker(const CMICmdInvoker &);
     void operator=(const CMICmdInvoker &);
     void CmdDeleteAll(void);
     bool CmdDelete(const MIuint vCmdId, const bool vbYesDeleteCmd = false);
     bool CmdAdd(const CMICmdBase &vCmd);
     bool CmdStdout(const SMICmdData &vCmdData) const;
     void CmdCauseAppExit(const CMICmdBase &vCmd) const;
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdInvoker(void);
+    /* dtor */ ~CMICmdInvoker(void) override;
     // From CMICmdMgrSetCmdDeleteCallback::ICallback
-    virtual void Delete(SMICmdData &vCmd);
+    void Delete(SMICmdData &vCmd) override;
 
     // Attributes:
   private:
     MapCmdIdToCmd_t m_mapCmdIdToCmd;
     CMICmnStreamStdout &m_rStreamOut;
 };

tools/lldb-mi/MICmdMgr.h

 // Changes: None.
 //--
 class CMICmdMgr : public CMICmnBase, public MI::ISingleton<CMICmdMgr>
 {
     friend class MI::ISingleton<CMICmdMgr>;
 
     // Methods:
   public:
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
 
     bool CmdInterpret(const CMIUtilString &vTextLine, bool &vwbYesValid, bool &vwbCmdNotInCmdFactor, SMICmdData &rwCmdData);
     bool CmdExecute(const SMICmdData &vCmdData);
     bool CmdDelete(SMICmdData vCmdData);
     bool CmdRegisterForDeleteNotification(CMICmdMgrSetCmdDeleteCallback::ICallback &vObject);
     bool CmdUnregisterForDeleteNotification(CMICmdMgrSetCmdDeleteCallback::ICallback &vObject);
 
     // Methods:
   private:
     /* ctor */ CMICmdMgr(void);
     /* ctor */ CMICmdMgr(const CMICmdMgr &);
     void operator=(const CMICmdMgr &);
 
     // Overridden:
   public:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmdMgr(void);
+    /* dtor */ ~CMICmdMgr(void) override;
 
     // Attributes:
   private:
     CMICmdInterpreter &m_interpretor;
     CMICmdFactory &m_factory;
     CMICmdInvoker &m_invoker;
     CMICmdMgrSetCmdDeleteCallback::CSetClients m_setCmdDeleteCallback;
 };

tools/lldb-mi/MICmdMgrSetCmdDeleteCallback.h

public:
 
     bool Register(class ICallback &vObject);
     bool Unregister(class ICallback &vObject);
     void Delete(SMICmdData &vCmdData);
 
     // Overridden:
   public:
     // From CMICmnBase
-    /* dtor */ virtual ~CSetClients(void);
+    /* dtor */ ~CSetClients(void) override;
 
     // Attributes:
   private:
     bool m_bClientUnregistered; // True = yes while deleting a client unregistered, false = no client unregistered during deletion
 };
 
 } // namespace CMICmdMgrSetCmdDeleteCallback

tools/lldb-mi/MICmnLLDBBroadcaster.h

 // Changes: None.
 //--
 class CMICmnLLDBBroadcaster : public CMICmnBase, public lldb::SBBroadcaster, public MI::ISingleton<CMICmnLLDBBroadcaster>
 {
     friend MI::ISingleton<CMICmnLLDBBroadcaster>;
 
     // Methods:
   public:
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
     // Methods:
   private:
     /* ctor */ CMICmnLLDBBroadcaster(void);
     /* ctor */ CMICmnLLDBBroadcaster(const CMICmnLLDBBroadcaster &);
     void operator=(const CMICmnLLDBBroadcaster &);
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnLLDBBroadcaster(void);
+    /* dtor */ ~CMICmnLLDBBroadcaster(void) override;
 };

tools/lldb-mi/MICmnLLDBDebugSessionInfo.h

public:
     };
 
     // Typedefs:
   public:
     typedef std::vector<uint32_t> VecActiveThreadId_t;
 
     // Methods:
   public:
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
 
     // Variant type data which can be assigned and retrieved across all command instances
     template <typename T> bool SharedDataAdd(const CMIUtilString &vKey, const T &vData);
     template <typename T> bool SharedDataRetrieve(const CMIUtilString &vKey, T &vwData);
     bool SharedDataDestroy(void);
 
     //  Common command required functionality
     bool AccessPath(const CMIUtilString &vPath, bool &vwbYesAccessible);
private:
     bool GetThreadFrames(const SMICmdData &vCmdData, const MIuint vThreadIdx, const FrameInfoFormat_e veFrameInfoFormat,
                          CMIUtilString &vwrThreadFrames);
     bool MIResponseForVariableInfoInternal(const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList,
                                            const lldb::SBValueList &vwrSBValueList, const MIuint vnMaxDepth, const bool vbIsArgs, const bool vbMarkArgs);
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnLLDBDebugSessionInfo(void);
+    /* dtor */ ~CMICmnLLDBDebugSessionInfo(void) override;
 
     // Attributes:
   private:
     CMIUtilMapIdToVariant m_mapIdToSessionData; // Hold and retrieve key to value data available across all commands
     VecVarObj_t m_vecVarObj;                    // Vector of session variable objects
     MapBrkPtIdToBrkPtInfo_t m_mapBrkPtIdToBrkPtInfo;
     CMIUtilThreadMutex m_sessionMutex;
 };

tools/lldb-mi/MICmnLLDBDebugger.h

 // Changes: None.
 //--
 class CMICmnLLDBDebugger : public CMICmnBase, public CMIUtilThreadActiveObjBase, public MI::ISingleton<CMICmnLLDBDebugger>
 {
     friend class MI::ISingleton<CMICmnLLDBDebugger>;
 
     // Methods:
   public:
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
 
     bool SetDriver(const CMIDriverBase &vClientDriver);
     CMIDriverBase &GetDriver(void) const;
     lldb::SBDebugger &GetTheDebugger(void);
     lldb::SBListener &GetTheListener(void);
     void WaitForHandleEvent(void);
     bool CheckIfNeedToRebroadcastStopEvent(void);
     void RebroadcastStopEvent(void);
 
     // MI Commands can use these functions to listen for events they require
     bool RegisterForEvent(const CMIUtilString &vClientName, const CMIUtilString &vBroadcasterClass, const MIuint vEventMask);
     bool UnregisterForEvent(const CMIUtilString &vClientName, const CMIUtilString &vBroadcasterClass);
     bool RegisterForEvent(const CMIUtilString &vClientName, const lldb::SBBroadcaster &vBroadcaster, const MIuint vEventMask);
     bool UnregisterForEvent(const CMIUtilString &vClientName, const lldb::SBBroadcaster &vBroadcaster);
 
     // Overridden:
   public:
     // From CMIUtilThreadActiveObjBase
-    virtual const CMIUtilString &ThreadGetName(void) const;
+    const CMIUtilString &ThreadGetName(void) const override;
 
     // Overridden:
   protected:
     // From CMIUtilThreadActiveObjBase
-    virtual bool ThreadRun(bool &vrIsAlive);
-    virtual bool ThreadFinish(void);
+    bool ThreadRun(bool &vrIsAlive) override;
+    bool ThreadFinish(void) override;
 
     // Typedefs:
   private:
     typedef std::map<CMIUtilString, MIuint> MapBroadcastClassNameToEventMask_t;
     typedef std::pair<CMIUtilString, MIuint> MapPairBroadcastClassNameToEventMask_t;
     typedef std::map<CMIUtilString, MIuint> MapIdToEventMask_t;
     typedef std::pair<CMIUtilString, MIuint> MapPairIdToEventMask_t;
 
private:
     MIuint ClientGetMaskForAllClients(const CMIUtilString &vBroadcasterClass) const;
     bool ClientSaveMask(const CMIUtilString &vClientName, const CMIUtilString &vBroadcasterClass, const MIuint vEventMask);
     bool ClientRemoveTheirMask(const CMIUtilString &vClientName, const CMIUtilString &vBroadcasterClass);
     bool ClientGetTheirMask(const CMIUtilString &vClientName, const CMIUtilString &vBroadcasterClass, MIuint &vwEventMask);
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnLLDBDebugger(void);
+    /* dtor */ ~CMICmnLLDBDebugger(void) override;
 
     // Attributes:
   private:
     CMIDriverBase *m_pClientDriver;  // The driver that wants to use *this LLDB debugger
     lldb::SBDebugger m_lldbDebugger; // SBDebugger is the primordial object that creates SBTargets and provides access to them
     lldb::SBListener m_lldbListener; // API clients can register its own listener to debugger events
     const CMIUtilString m_constStrThisThreadId;
     MapBroadcastClassNameToEventMask_t m_mapBroadcastClassNameToEventMask;
     MapIdToEventMask_t m_mapIdToEventMask;
     std::mutex m_mutexEventQueue;
     std::condition_variable m_conditionEventQueueEmpty;
     uint32_t m_nLastStopId;
 };

tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.h

 // Changes: None.
 //--
 class CMICmnLLDBDebuggerHandleEvents : public CMICmnBase, public MI::ISingleton<CMICmnLLDBDebuggerHandleEvents>
 {
     friend class MI::ISingleton<CMICmnLLDBDebuggerHandleEvents>;
 
     // Methods:
   public:
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
     //
     bool HandleEvent(const lldb::SBEvent &vEvent, bool &vrbHandledEvent);
 
     // Methods:
   private:
     /* ctor */ CMICmnLLDBDebuggerHandleEvents(void);
     /* ctor */ CMICmnLLDBDebuggerHandleEvents(const CMICmnLLDBDebuggerHandleEvents &);
     void operator=(const CMICmnLLDBDebuggerHandleEvents &);
private:
     bool MiStoppedAtBreakPoint(const MIuint64 vBrkPtId, const lldb::SBBreakpoint &vBrkPt);
     bool TextToStdout(const CMIUtilString &vrTxt);
     bool TextToStderr(const CMIUtilString &vrTxt);
     bool UpdateSelectedThread(void);
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnLLDBDebuggerHandleEvents(void);
+    /* dtor */ ~CMICmnLLDBDebuggerHandleEvents(void) override;
     void InitializeSignals();
     bool m_bSignalsInitialized;
     MIuint64 m_SIGINT;
     MIuint64 m_SIGSTOP;
     MIuint64 m_SIGSEGV;
     MIuint64 m_SIGTRAP;
 };

tools/lldb-mi/MICmnLog.h

public:
     // Done to stop locking on object construction init circular dependency.
     const CMIUtilString &GetErrorDescription(void) const;
     void SetErrorDescription(const CMIUtilString &vrTxt) const;
     void ClrErrorDescription(void) const;
 
     // Overridden:
   public:
     // From MI::ISingleton
-    virtual bool Initialize(void);
-    virtual bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
 
     // Methods:
   private:
     /* ctor */ CMICmnLog(void);
     /* ctor */ CMICmnLog(const CMICmnLog &);
     void operator=(const CMICmnLog &);
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnLog(void);
+    /* dtor */ ~CMICmnLog(void) override;
 
     // Typedef:
   private:
     typedef std::map<IMedium *, CMIUtilString> MapMediumToName_t;
     typedef std::pair<IMedium *, CMIUtilString> MapPairMediumToName_t;
 
     // Methods:
   private:

tools/lldb-mi/MICmnLogMediumFile.h

public:
     bool IsOk(void) const;
     bool IsFileExist(void) const;
     const CMIUtilString &GetLineReturn(void) const;
     bool SetDirectory(const CMIUtilString &vPath);
 
     // Overridden:
   public:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnLogMediumFile(void);
+    /* dtor */ ~CMICmnLogMediumFile(void) override;
     // From CMICmnLog::IMedium
-    virtual bool Initialize(void);
-    virtual const CMIUtilString &GetName(void) const;
-    virtual bool Write(const CMIUtilString &vData, const CMICmnLog::ELogVerbosity veType);
-    virtual const CMIUtilString &GetError(void) const;
-    virtual bool Shutdown(void);
+    bool Initialize(void) override;
+    const CMIUtilString &GetName(void) const override;
+    bool Write(const CMIUtilString &vData, const CMICmnLog::ELogVerbosity veType) override;
+    const CMIUtilString &GetError(void) const override;
+    bool Shutdown(void) override;
 
     // Methods:
   private:
     /* ctor */ CMICmnLogMediumFile(void);
     /* ctor */ CMICmnLogMediumFile(const CMICmnLogMediumFile &);
     void operator=(const CMICmnLogMediumFile &);
 
     bool FileWriteEnglish(const CMIUtilString &vData);

tools/lldb-mi/MICmnMIOutOfBandRecord.h

public:
     /* ctor */ CMICmnMIOutOfBandRecord(const OutOfBand_e veType, const CMICmnMIValueResult &vResult);
     //
     const CMIUtilString &GetString(void) const;
     bool Add(const CMICmnMIValueResult &vResult);
 
     // Overridden:
   public:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnMIOutOfBandRecord(void);
+    /* dtor */ ~CMICmnMIOutOfBandRecord(void) override;
 
     // Methods:
   private:
     bool BuildAsyncRecord(void);
 
     // Attributes:
   private:
     static MapOutOfBandToOutOfBandText_t ms_constMapOutOfBandToAsyncRecordText;
     static MapOutOfBandToToken_t ms_constMapOutOfBandTextToToken;
     //
     OutOfBand_e m_eResultAsyncRecordClass;
     CMIUtilString m_strAsyncRecord; // Holds the text version of the result record to date
     CMICmnMIValueResult m_partResult;
 };

tools/lldb-mi/MICmnMIResultRecord.h

public:
     /* ctor */ CMICmnMIResultRecord(const CMIUtilString &vrToken, const ResultClass_e veType, const CMICmnMIValueResult &vValue);
     //
     const CMIUtilString &GetString(void) const;
     bool Add(const CMICmnMIValue &vMIValue);
 
     // Overridden:
   public:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnMIResultRecord(void);
+    /* dtor */ ~CMICmnMIResultRecord(void) override;
 
     // Methods:
   private:
     bool BuildResultRecord(void);
 
     // Attributes:
   private:
     static const CMIUtilString ms_constStrResultRecordHat;
     static MapResultClassToResultClassText_t ms_constMapResultClassToResultClassText;
     //
     CMIUtilString m_strResultRecordToken;
     ResultClass_e m_eResultRecordResultClass;
     CMIUtilString m_strResultRecord; // Holds the text version of the result record to date
     CMICmnMIValueResult m_partResult;
 };

tools/lldb-mi/MICmnMIValue.h

class CMICmnMIValue : public CMICmnBase
   public:
     /* ctor */ CMICmnMIValue(void);
     //
     const CMIUtilString &GetString(void) const;
 
     // Overridden:
   public:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnMIValue(void);
+    /* dtor */ ~CMICmnMIValue(void) override;
 
     // Attributes:
   protected:
     CMIUtilString m_strValue;
     bool m_bJustConstructed; // True = *this just constructed with no value, false = *this has had value added to it
 };

tools/lldb-mi/MICmnMIValueConst.h

class CMICmnMIValueConst : public CMICmnMIValue
     // Methods:
   public:
     /* ctor */ CMICmnMIValueConst(const CMIUtilString &vString);
     /* ctor */ CMICmnMIValueConst(const CMIUtilString &vString, const bool vbNoQuotes);
 
     // Overridden:
   public:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnMIValueConst(void);
+    /* dtor */ ~CMICmnMIValueConst(void) override;
 
     // Methods:
   private:
     bool BuildConst(void);
 
     // Attributes:
   private:
     static const CMIUtilString ms_constStrDblQuote;
     //
     CMIUtilString m_strPartConst;
     bool m_bNoQuotes; // True = return string not surrounded with quotes, false = use quotes
 };

tools/lldb-mi/MICmnMIValueList.h

public:
     //
     bool Add(const CMICmnMIValueResult &vResult);
     bool Add(const CMICmnMIValue &vValue);
     CMIUtilString ExtractContentNoBrackets(void) const;
 
     // Overridden:
   public:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnMIValueList(void);
+    /* dtor */ ~CMICmnMIValueList(void) override;
 
     // Methods:
   private:
     bool BuildList(void);
     bool BuildList(const CMICmnMIValueResult &vResult);
     bool BuildList(const CMICmnMIValue &vResult);
 };

tools/lldb-mi/MICmnMIValueResult.h

public:
     /* ctor */ CMICmnMIValueResult(const CMIUtilString &vVariable, const CMICmnMIValue &vValue);
     /* ctor */ CMICmnMIValueResult(const CMIUtilString &vVariable, const CMICmnMIValue &vValue, const bool vbUseSpacing);
     //
     bool Add(const CMIUtilString &vVariable, const CMICmnMIValue &vValue);
 
     // Overridden:
   public:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnMIValueResult(void);
+    /* dtor */ ~CMICmnMIValueResult(void) override;
 
     // Methods:
   private:
     bool BuildResult(void);
     bool BuildResult(const CMIUtilString &vVariable, const CMICmnMIValue &vValue);
 
     // Attributes:
   private:
     static const CMIUtilString ms_constStrEqual;
     //
     CMIUtilString m_strPartVariable;
     CMICmnMIValue m_partMIValue;
     bool m_bEmptyConstruction; // True = *this object used constructor with no parameters, false = constructor with parameters
     bool m_bUseSpacing;        // True = put space separators into the string, false = no spaces used
 };

tools/lldb-mi/MICmnMIValueTuple.h

public:
     bool Add(const CMICmnMIValueResult &vResult);
     bool Add(const CMICmnMIValueResult &vResult, const bool vbUseSpacing);
     bool Add(const CMICmnMIValueConst &vValue, const bool vbUseSpacing);
     CMIUtilString ExtractContentNoBrackets(void) const;
 
     // Overridden:
   public:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnMIValueTuple(void);
+    /* dtor */ ~CMICmnMIValueTuple(void) override;
 
     // Methods:
   private:
     bool BuildTuple(void);
     bool BuildTuple(const CMICmnMIValueResult &vResult);
     bool BuildTuple(const CMIUtilString &vValue);
 
     // Attributes:
   private:
     bool m_bSpaceAfterComma; // True = put space separators into the string, false = no spaces used
 };

tools/lldb-mi/MICmnResources.h

 // Changes: None.
 //--
 class CMICmnResources : public CMICmnBase, public MI::ISingleton<CMICmnResources>
 {
     friend class MI::ISingleton<CMICmnResources>;
 
     // Methods:
   public:
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
 
     CMIUtilString GetString(const MIuint vResourceId) const;
     bool HasString(const MIuint vResourceId) const;
 
     // Typedef:
   private:
     typedef std::map<MIuint, const char *> MapRscrIdToTextData_t;
     typedef std::pair<MIuint, const char *> MapPairRscrIdToTextData_t;
private:
     void operator=(const CMICmnResources &);
 
     bool GetStringFromResource(const MIuint vResourceId, CMIUtilString &vrwResourceString) const;
     bool ReadResourceStringData(void);
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnResources(void);
+    /* dtor */ ~CMICmnResources(void) override;
 
     // Attributes:
   private:
     static const SRsrcTextData ms_pResourceId2TextData[];
     //
     MIuint m_nResourceId2TextDataSize;
     MapRscrIdToTextData_t m_mapRscrIdToTextData;
 };
 
 //++ =========================================================================
 // Details: Macro short cut for retrieving a text data resource
 //--
 #define MIRSRC(x) CMICmnResources::Instance().GetString(x).c_str()

tools/lldb-mi/MICmnStreamStderr.h

class CMICmnStreamStderr : public CMICmnBase, public MI::ISingleton<CMICmnStreamStderr>
 
     // Statics:
   public:
     static bool TextToStderr(const CMIUtilString &vrTxt);
     static bool LLDBMsgToConsole(const CMIUtilString &vrTxt);
 
     // Methods:
   public:
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
     //
     bool Lock(void);
     bool Unlock(void);
     bool Write(const CMIUtilString &vText, const bool vbSendToLog = true);
     bool WriteLLDBMsg(const CMIUtilString &vText, const bool vbSendToLog = true);
 
     // Methods:
   private:
     /* ctor */ CMICmnStreamStderr(void);
     /* ctor */ CMICmnStreamStderr(const CMICmnStreamStderr &);
     void operator=(const CMICmnStreamStderr &);
     //
     bool WritePriv(const CMIUtilString &vText, const CMIUtilString &vTxtForLogFile, const bool vbSendToLog = true);
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnStreamStderr(void);
+    /* dtor */ ~CMICmnStreamStderr(void) override;
 
     // Attributes:
   private:
     CMIUtilThreadMutex m_mutex; // Mutex object for sync during Write()
 };

tools/lldb-mi/MICmnStreamStdin.h

 //--
 class CMICmnStreamStdin : public CMICmnBase, public MI::ISingleton<CMICmnStreamStdin>
 {
     // Give singleton access to private constructors
     friend MI::ISingleton<CMICmnStreamStdin>;
 
     // Methods:
   public:
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
     //
     const CMIUtilString &GetPrompt(void) const;
     bool SetPrompt(const CMIUtilString &vNewPrompt);
     void SetEnablePrompt(const bool vbYes);
     bool GetEnablePrompt(void) const;
     const char *ReadLine(CMIUtilString &vwErrMsg);
 
     // Methods:
   private:
     /* ctor */ CMICmnStreamStdin(void);
     /* ctor */ CMICmnStreamStdin(const CMICmnStreamStdin &);
     void operator=(const CMICmnStreamStdin &);
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnStreamStdin(void);
+    /* dtor */ ~CMICmnStreamStdin(void) override;
 
     // Attributes:
   private:
     CMIUtilString m_strPromptCurrent; // Command line prompt as shown to the user
     bool m_bShowPrompt;               // True = Yes prompt is shown/output to the user (stdout), false = no prompt
     static const int m_constBufferSize = 2048;
     char *m_pCmdBuffer;
 };

tools/lldb-mi/MICmnStreamStdout.h

class CMICmnStreamStdout : public CMICmnBase, public MI::ISingleton<CMICmnStreamStdout>
 
     // Statics:
   public:
     static bool TextToStdout(const CMIUtilString &vrTxt);
     static bool WritePrompt(void);
 
     // Methods:
   public:
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
     //
     bool Lock(void);
     bool Unlock(void);
     bool Write(const CMIUtilString &vText, const bool vbSendToLog = true);
     bool WriteMIResponse(const CMIUtilString &vText, const bool vbSendToLog = true);
 
     // Methods:
   private:
     /* ctor */ CMICmnStreamStdout(void);
     /* ctor */ CMICmnStreamStdout(const CMICmnStreamStdout &);
     void operator=(const CMICmnStreamStdout &);
     //
     bool WritePriv(const CMIUtilString &vText, const CMIUtilString &vTxtForLogFile, const bool vbSendToLog = true);
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnStreamStdout(void);
+    /* dtor */ ~CMICmnStreamStdout(void) override;
 
     // Attributes:
   private:
     CMIUtilThreadMutex m_mutex; // Mutex object for sync during writing to stream
 };

tools/lldb-mi/MICmnThreadMgrStd.h

 // Changes: None.
 //--
 class CMICmnThreadMgrStd : public CMICmnBase, public MI::ISingleton<CMICmnThreadMgrStd>
 {
     friend MI::ISingleton<CMICmnThreadMgrStd>;
 
     // Methods:
   public:
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
     bool
     ThreadAllTerminate(void); // Ask all threads to stop (caution)
     template <typename T>     // Ask the thread manager to start and stop threads on our behalf
     bool ThreadStart(T &vrwObject);
 
     // Typedef:
   private:
     typedef std::vector<CMIUtilThreadActiveObjBase *> ThreadList_t;
 
     // Methods:
   private:
     /* ctor */ CMICmnThreadMgrStd(void);
     /* ctor */ CMICmnThreadMgrStd(const CMICmnThreadMgrStd &);
     void operator=(const CMICmnThreadMgrStd &);
     //
     bool
     AddThread(const CMIUtilThreadActiveObjBase &vrObj); // Add a thread for monitoring by the threadmanager
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMICmnThreadMgrStd(void);
+    /* dtor */ ~CMICmnThreadMgrStd(void) override;
 
     // Attributes:
   private:
     CMIUtilThreadMutex m_mutex;
     ThreadList_t m_threadList;
 };
 
 //++ ------------------------------------------------------------------------------------

tools/lldb-mi/MIDriver.h

enum DriverState_e
         eDriverState_RunningDebugging,    // The MI Driver is currently overseeing an inferior program that is running
         eDriverState_ShuttingDown,        // The MI Driver is tearing down resources and about exit
         eDriverState_count                // Always last
     };
 
     // Methods:
   public:
     // MI system
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
 
     // MI state
     bool GetExitApplicationFlag(void) const;
     DriverState_e GetCurrentDriverState(void) const;
     bool SetDriverStateRunningNotDebugging(void);
     bool SetDriverStateRunningDebugging(void);
     void SetDriverDebuggingArgExecutable(void);
     bool IsDriverDebuggingArgExecutable(void) const;
 
     // MI information about itself
     const CMIUtilString &GetAppNameShort(void) const;
     const CMIUtilString &GetAppNameLong(void) const;
     const CMIUtilString &GetVersionDescription(void) const;
 
     // MI do work
     bool WriteMessageToLog(const CMIUtilString &vMessage);
     bool SetEnableFallThru(const bool vbYes);
     bool GetEnableFallThru(void) const;
     bool HaveExecutableFileNamePathOnCmdLine(void) const;
     const CMIUtilString &GetExecutableFileNamePathOnCmdLine(void) const;
 
     // Overridden:
   public:
     // From CMIDriverMgr::IDriver
-    virtual bool DoInitialize(void);
-    virtual bool DoShutdown(void);
-    virtual bool DoMainLoop(void);
-    virtual lldb::SBError DoParseArgs(const int argc, const char *argv[], FILE *vpStdOut, bool &vwbExiting);
-    virtual CMIUtilString GetError(void) const;
-    virtual const CMIUtilString &GetName(void) const;
-    virtual lldb::SBDebugger &GetTheDebugger(void);
-    virtual bool GetDriverIsGDBMICompatibleDriver(void) const;
-    virtual bool SetId(const CMIUtilString &vId);
-    virtual const CMIUtilString &GetId(void) const;
+    bool DoInitialize(void) override;
+    bool DoShutdown(void) override;
+    bool DoMainLoop(void) override;
+    lldb::SBError DoParseArgs(const int argc, const char *argv[], FILE *vpStdOut, bool &vwbExiting) override;
+    CMIUtilString GetError(void) const override;
+    const CMIUtilString &GetName(void) const override;
+    lldb::SBDebugger &GetTheDebugger(void) override;
+    bool GetDriverIsGDBMICompatibleDriver(void) const override;
+    bool SetId(const CMIUtilString &vId) override;
+    const CMIUtilString &GetId(void) const override;
     // From CMIDriverBase
-    virtual void SetExitApplicationFlag(const bool vbForceExit);
-    virtual bool DoFallThruToAnotherDriver(const CMIUtilString &vCmd, CMIUtilString &vwErrMsg);
-    virtual bool SetDriverToFallThruTo(const CMIDriverBase &vrOtherDriver);
-    virtual FILE *GetStdin(void) const;
-    virtual FILE *GetStdout(void) const;
-    virtual FILE *GetStderr(void) const;
-    virtual const CMIUtilString &GetDriverName(void) const;
-    virtual const CMIUtilString &GetDriverId(void) const;
-    virtual void DeliverSignal(int signal);
+    void SetExitApplicationFlag(const bool vbForceExit) override;
+    bool DoFallThruToAnotherDriver(const CMIUtilString &vCmd, CMIUtilString &vwErrMsg) override;
+    bool SetDriverToFallThruTo(const CMIDriverBase &vrOtherDriver) override;
+    FILE *GetStdin(void) const override;
+    FILE *GetStdout(void) const override;
+    FILE *GetStderr(void) const override;
+    const CMIUtilString &GetDriverName(void) const override;
+    const CMIUtilString &GetDriverId(void) const override;
+    void DeliverSignal(int signal) override;
 
     // Typedefs:
   private:
     typedef std::queue<CMIUtilString> QueueStdinLine_t;
 
     // Methods:
   private:
     /* ctor */ CMIDriver(void);
private:
     bool InitClientIDEToMIDriver(void) const;
     bool InitClientIDEEclipse(void) const;
     bool LocalDebugSessionStartupExecuteCommands(void);
     bool ExecuteCommandFile(const bool vbAsyncMode);
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMIDriver(void);
+    /* dtor */ ~CMIDriver(void) override;
 
     // Attributes:
   private:
     static const CMIUtilString ms_constAppNameShort;
     static const CMIUtilString ms_constAppNameLong;
     static const CMIUtilString ms_constMIVersion;
     //
     bool m_bFallThruToOtherDriverEnabled; // True = yes fall through, false = do not pass on command

tools/lldb-mi/MIDriverMgr.h

class IDriver
 
         // Not part of the interface, ignore
         /* dtor */ virtual ~IDriver(void) {}
     };
 
     // Methods:
   public:
     // MI system
-    bool Initialize(void);
-    bool Shutdown(void);
+    bool Initialize(void) override;
+    bool Shutdown(void) override;
     //
     CMIUtilString GetAppVersion(void) const;
     bool RegisterDriver(const IDriver &vrADriver, const CMIUtilString &vrDriverID);
     bool UnregisterDriver(const IDriver &vrADriver);
     bool
     SetUseThisDriverToDoWork(const IDriver &vrADriver); // Specify working main driver
     IDriver *GetUseThisDriverToDoWork(void) const;
     bool ParseArgs(const int argc, const char *argv[], bool &vwbExiting);
private:
     bool UnregisterDriverAll(void);
     IDriver *GetFirstMIDriver(void) const;
     IDriver *GetFirstNonMIDriver(void) const;
     CMIUtilString GetHelpOnCmdLineArgOptions(void) const;
 
     // Overridden:
   private:
     // From CMICmnBase
-    /* dtor */ virtual ~CMIDriverMgr(void);
+    /* dtor */ ~CMIDriverMgr(void) override;
 
     // Attributes:
   private:
     MapDriverIdToDriver_t m_mapDriverIdToDriver;
     IDriver *m_pDriverCurrent; // This driver is used by this manager to do work. It is the main driver.
     bool m_bInMi2Mode;         // True = --interpreter entered on the cmd line, false = operate LLDB driver (non GDB)
 };

tools/lldb-mi/MIUtilFileStd.h

public:
     bool IsOk(void) const;
     bool IsFileExist(const CMIUtilString &vFileNamePath) const;
     const CMIUtilString &GetLineReturn(void) const;
     static CMIUtilString StripOffFileName(const CMIUtilString &vDirectoryPath);
 
     // Overridden:
   public:
     // From CMICmnBase
-    /* dtor */ virtual ~CMIUtilFileStd(void);
+    /* dtor */ ~CMIUtilFileStd(void) override;
 
     // Attributes:
   private:
     CMIUtilString m_fileNamePath;
     FILE *m_pFileHandle;
     CMIUtilString m_constCharNewLine;
     bool m_bFileError; // True = have a file error ATM, false = all ok
 };

tools/lldb-mi/MIUtilMapIdToVariant.h

public:
     template <typename T> bool Get(const CMIUtilString &vId, T &vrwData, bool &vrwbFound) const;
     bool HaveAlready(const CMIUtilString &vId) const;
     bool IsEmpty(void) const;
     bool Remove(const CMIUtilString &vId);
 
     // Overridden:
   public:
     // From CMICmnBase
-    /* dtor */ virtual ~CMIUtilMapIdToVariant(void);
+    /* dtor */ ~CMIUtilMapIdToVariant(void) override;
 
     // Typdefs:
   private:
     typedef std::map<CMIUtilString, CMIUtilVariant> MapKeyToVariantValue_t;
     typedef std::pair<CMIUtilString, CMIUtilVariant> MapPairKeyToVariantValue_t;
 
     // Methods:
   private:

tools/lldb-mi/MIUtilSingletonBase.h

 //   class CMIDerivedClass
 //       : public MI::ISingleton< CMIDerivedClass >
 //   {
 //       friend MI::ISingleton< CMIDerivedClass >;
 //
 //   // Overridden:
 //   public:
 //       // From MI::ISingleton
-//       virtual bool Initialize( void );
-//       virtual bool Shutdown( void );
+//       bool Initialize(void) override;
+//       bool Shutdown(void) override;
 //   };
 
 //++ ============================================================================
 // Details: Base class for the singleton pattern.
 // Gotchas: Derived class must specify MI::ISingleton<> as a friend class.
 // Authors: Aidan Dodds 17/03/2014.
 // Changes: None.
 //--

tools/lldb-mi/MIUtilVariant.h

template <typename T> class CDataObject : public CDataObjectBase
         CDataObject &operator=(const CDataObject &vrOther);
         CDataObject &operator=(CDataObject &&vrwOther);
         //
         T &GetDataObject(void);
 
         // Overridden:
       public:
         // From CDataObjectBase
-        virtual ~CDataObject(void);
-        virtual CDataObjectBase *CreateCopyOfSelf(void);
-        virtual bool GetIsDerivedClass(void) const;
+        ~CDataObject(void) override;
+        CDataObjectBase *CreateCopyOfSelf(void) override;
+        bool GetIsDerivedClass(void) const override;
 
         // Overrideable:
       private:
         virtual void Duplicate(const CDataObject &vrOther);
 
         // Overridden:
       private:
         // From CDataObjectBase
-        virtual void Destroy(void);
+        void Destroy(void) override;
 
         // Attributes:
       private:
         T m_dataObj;
     };
 
     // Methods
   private: