[LLDB] Fix Clang-tidy misc-use-override warnings in some files in include/lldb/Interpreter, unify closing inclusion guards

[Eugene.Zelenko]

Summary

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

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

[Eugene.Zelenko]

Sorry, forgot to update after fixing two Clang warnings.

[labath]

committed as r246627.

lldb/trunk/include/lldb/Interpreter/OptionValueArch.h

public:
     OptionValueArch (const ArchSpec &current_value,
                      const ArchSpec &default_value) :
         OptionValue(),
         m_current_value (current_value),
         m_default_value (default_value)
     {
     }
     
-    virtual 
-    ~OptionValueArch()
+    ~OptionValueArch() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypeArch;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
     
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;
     }
     
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
 
-    virtual size_t
-    AutoComplete (CommandInterpreter &interpreter,
-                  const char *s,
-                  int match_start_point,
-                  int max_return_elements,
-                  bool &word_complete,
-                  StringList &matches);
+    size_t
+    AutoComplete(CommandInterpreter &interpreter,
+     const char *s,
+     int match_start_point,
+     int max_return_elements,
+     bool &word_complete,
+     StringList &matches) override;
     
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
     
     ArchSpec &
     GetCurrentValue()
     {

     
 protected:
     ArchSpec m_current_value;
     ArchSpec m_default_value;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueArch_h_
+#endif // liblldb_OptionValueArch_h_

lldb/trunk/include/lldb/Interpreter/OptionValueArgs.h

 class OptionValueArgs : public OptionValueArray
 {
 public:
     OptionValueArgs () :
         OptionValueArray (OptionValue::ConvertTypeToMask (OptionValue::eTypeString))
     {
     }
     
-    virtual
-    ~OptionValueArgs()
+    ~OptionValueArgs() override
     {
     }
     
     size_t
     GetArgs (Args &args);
     
-    virtual Type
-    GetType() const
+    Type
+    GetType() const override
     {
         return eTypeArgs;
     }
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueArgs_h_
+#endif // liblldb_OptionValueArgs_h_

lldb/trunk/include/lldb/Interpreter/OptionValueArray.h

 public:
     OptionValueArray (uint32_t type_mask = UINT32_MAX, bool raw_value_dump = false) :
         m_type_mask (type_mask),
         m_values (),
         m_raw_value_dump(raw_value_dump)
     {
     }
     
-    virtual 
-    ~OptionValueArray()
+    ~OptionValueArray() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypeArray;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
     
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_values.clear();
         m_value_was_set = false;
         return true;
     }
     
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
     
-    virtual bool
-    IsAggregateValue () const
+    bool
+    IsAggregateValue() const override
     {
         return true;
     }
     
-    virtual lldb::OptionValueSP
-    GetSubValue (const ExecutionContext *exe_ctx,
-                 const char *name,
-                 bool will_modify,
-                 Error &error) const;
+    lldb::OptionValueSP
+    GetSubValue(const ExecutionContext *exe_ctx,
+    const char *name,
+    bool will_modify,
+    Error &error) const override;
     
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
 
     size_t
     GetSize () const
     {
protected:
             
     uint32_t m_type_mask;
     collection m_values;
     bool m_raw_value_dump;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueArray_h_
+#endif // liblldb_OptionValueArray_h_

lldb/trunk/include/lldb/Interpreter/OptionValueBoolean.h

public:
     OptionValueBoolean (bool current_value,
                         bool default_value) :
         OptionValue(),
         m_current_value (current_value),
         m_default_value (default_value)
     {
     }
     
-    virtual 
-    ~OptionValueBoolean()
+    ~OptionValueBoolean() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypeBoolean;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
     
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;
     }
 
-    virtual size_t
-    AutoComplete (CommandInterpreter &interpreter,
-                  const char *s,
-                  int match_start_point,
-                  int max_return_elements,
-                  bool &word_complete,
-                  StringList &matches);
+    size_t
+    AutoComplete(CommandInterpreter &interpreter,
+     const char *s,
+     int match_start_point,
+     int max_return_elements,
+     bool &word_complete,
+     StringList &matches) override;
 
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
     
     //------------------------------------------------------------------
     /// Convert to bool operator.
     ///
public:
     }
     
     void
     SetDefaultValue (bool value)
     {
         m_default_value = value;
     }
     
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
 
 protected:
     bool m_current_value;
     bool m_default_value;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueBoolean_h_
+#endif // liblldb_OptionValueBoolean_h_

lldb/trunk/include/lldb/Interpreter/OptionValueChar.h

 {
 public:
     OptionValueChar (char value) :
         OptionValue(),
         m_current_value (value),
         m_default_value (value)
     {
     }
+
     OptionValueChar (char current_value,
                      char default_value) :
         OptionValue(),
         m_current_value (current_value),
         m_default_value (default_value)
     {
     }
     
-    virtual 
-    ~OptionValueChar()
+    ~OptionValueChar() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypeChar;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
     
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;
     }
 
     //---------------------------------------------------------------------
     // Subclass specific functions
public:
     }
     
     void
     SetDefaultValue (char value)
     {
         m_default_value = value;
     }
     
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
 
 protected:
     char m_current_value;
     char m_default_value;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueChar_h_
+#endif // liblldb_OptionValueChar_h_

lldb/trunk/include/lldb/Interpreter/OptionValueDictionary.h

public:
     OptionValueDictionary (uint32_t type_mask = UINT32_MAX, bool raw_value_dump = true) :
         OptionValue(),
         m_type_mask (type_mask),
         m_values (),
         m_raw_value_dump (raw_value_dump)
     {
     }
     
-    virtual 
-    ~OptionValueDictionary()
+    ~OptionValueDictionary() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypeDictionary;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
     
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_values.clear();
         m_value_was_set = false;
         return true;
     }
     
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
     
-    virtual bool
-    IsAggregateValue () const
+    bool
+    IsAggregateValue() const override
     {
         return true;
     }
 
     bool
     IsHomogenous() const
     {
         return ConvertTypeMaskToType (m_type_mask) != eTypeInvalid;
     }
 
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
     
     size_t
     GetNumValues() const
     {
         return m_values.size();
     }
     
     lldb::OptionValueSP
     GetValueForKey (const ConstString &key) const;
     
-    virtual lldb::OptionValueSP
-    GetSubValue (const ExecutionContext *exe_ctx,
-                 const char *name,
-                 bool will_modify,
-                 Error &error) const;
+    lldb::OptionValueSP
+    GetSubValue(const ExecutionContext *exe_ctx,
+    const char *name,
+    bool will_modify,
+    Error &error) const override;
     
-    virtual Error
-    SetSubValue (const ExecutionContext *exe_ctx,
-                 VarSetOperationType op,
-                 const char *name,
-                 const char *value);
+    Error
+    SetSubValue(const ExecutionContext *exe_ctx,
+    VarSetOperationType op,
+    const char *name,
+    const char *value) override;
 
     //---------------------------------------------------------------------
     // String value getters and setters
     //---------------------------------------------------------------------
     const char *
     GetStringValueForKey (const ConstString &key);
 
     bool
protected:
     typedef std::map<ConstString, lldb::OptionValueSP> collection;
     uint32_t m_type_mask;
     collection m_values;
     bool m_raw_value_dump;
 };
     
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueDictionary_h_
+#endif // liblldb_OptionValueDictionary_h_

lldb/trunk/include/lldb/Interpreter/OptionValueEnumeration.h

 #include "lldb/Core/Error.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Interpreter/OptionValue.h"
 
 namespace lldb_private {
 
-
 class OptionValueEnumeration : public OptionValue
 {
 public:
     typedef int64_t enum_type;
     struct EnumeratorInfo
     {
         enum_type value;
         const char *description;
     };
     typedef UniqueCStringMap<EnumeratorInfo> EnumerationMap;
     typedef EnumerationMap::Entry EnumerationMapEntry;
 
     OptionValueEnumeration (const OptionEnumValueElement *enumerators, enum_type value);
     
-    virtual
-    ~OptionValueEnumeration();
+    ~OptionValueEnumeration() override;
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypeEnum;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
     
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;
     }
     
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
     
-    virtual size_t
-    AutoComplete (CommandInterpreter &interpreter,
-                  const char *s,
-                  int match_start_point,
-                  int max_return_elements,
-                  bool &word_complete,
-                  StringList &matches);
+    size_t
+    AutoComplete(CommandInterpreter &interpreter,
+     const char *s,
+     int match_start_point,
+     int max_return_elements,
+     bool &word_complete,
+     StringList &matches) override;
 
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
     
     enum_type
     operator = (enum_type value)
     {
protected:
 
     enum_type m_current_value;
     enum_type m_default_value;
     EnumerationMap m_enumerations;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueEnumeration_h_
+#endif // liblldb_OptionValueEnumeration_h_

lldb/trunk/include/lldb/Interpreter/OptionValueFileSpec.h

public:
     
     OptionValueFileSpec (const FileSpec &value,
                          bool resolve = true);
     
     OptionValueFileSpec (const FileSpec &current_value, 
                          const FileSpec &default_value,
                          bool resolve = true);
     
-    virtual 
-    ~OptionValueFileSpec()
+    ~OptionValueFileSpec() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypeFileSpec;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
     
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         m_data_sp.reset();
         m_data_mod_time.Clear();
         return true;
     }
     
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
 
-    virtual size_t
-    AutoComplete (CommandInterpreter &interpreter,
-                  const char *s,
-                  int match_start_point,
-                  int max_return_elements,
-                  bool &word_complete,
-                  StringList &matches);
+    size_t
+    AutoComplete(CommandInterpreter &interpreter,
+     const char *s,
+     int match_start_point,
+     int max_return_elements,
+     bool &word_complete,
+     StringList &matches) override;
     
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
     
     FileSpec &
     GetCurrentValue()
     {
protected:
     lldb::DataBufferSP m_data_sp;
     TimeValue m_data_mod_time;
     uint32_t m_completion_mask;
     bool m_resolve;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueFileSpec_h_
+#endif // liblldb_OptionValueFileSpec_h_

lldb/trunk/include/lldb/Interpreter/OptionValueFileSpecList.h

public:
     }
     
     OptionValueFileSpecList (const FileSpecList &current_value) :
         OptionValue(),
         m_current_value (current_value)
     {
     }
     
-    
-    virtual 
-    ~OptionValueFileSpecList()
+    ~OptionValueFileSpecList() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypeFileSpecList;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
     
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_current_value.Clear();
         m_value_was_set = false;
         return true;
     }
     
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
     
-    virtual bool
-    IsAggregateValue () const
+    bool
+    IsAggregateValue() const override
     {
         return true;
     }
 
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
     
public:
     }
     
 protected:
     FileSpecList m_current_value;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueFileSpecList_h_
+#endif // liblldb_OptionValueFileSpecList_h_

lldb/trunk/include/lldb/Interpreter/OptionValueFormat.h

public:
     OptionValueFormat (lldb::Format current_value,
                        lldb::Format default_value) :
         OptionValue(),
         m_current_value (current_value),
         m_default_value (default_value)
     {
     }
     
-    virtual 
-    ~OptionValueFormat()
+    ~OptionValueFormat() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypeFormat;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
     
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;
     }
 
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
     
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
     
     lldb::Format
     GetCurrentValue() const
     {

     
 protected:
     lldb::Format m_current_value;
     lldb::Format m_default_value;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueFormat_h_
+#endif // liblldb_OptionValueFormat_h_

lldb/trunk/include/lldb/Interpreter/OptionValueFormatEntity.h

 
 namespace lldb_private {
 
 class OptionValueFormatEntity : public OptionValue
 {
 public:
     OptionValueFormatEntity (const char *default_format);
     
-    virtual
-    ~OptionValueFormatEntity()
+    ~OptionValueFormatEntity() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
     OptionValue::Type
public:
     }
     
     const FormatEntity::Entry &
     GetDefaultValue() const
     {
         return m_default_entry;
     }
 
-
 protected:
     std::string m_current_format;
     std::string m_default_format;
     FormatEntity::Entry m_current_entry;
     FormatEntity::Entry m_default_entry;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueFormatEntity_h_
+#endif // liblldb_OptionValueFormatEntity_h_

lldb/trunk/include/lldb/Interpreter/OptionValueLanguage.h

public:
     OptionValueLanguage (lldb::LanguageType current_value,
                          lldb::LanguageType default_value) :
         OptionValue(),
         m_current_value (current_value),
         m_default_value (default_value)
     {
     }
     
-    virtual 
-    ~OptionValueLanguage ()
+    ~OptionValueLanguage() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
     OptionValue::Type

     
 protected:
     lldb::LanguageType m_current_value;
     lldb::LanguageType m_default_value;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueLanguage_h_
+#endif // liblldb_OptionValueLanguage_h_

lldb/trunk/include/lldb/Interpreter/OptionValuePathMappings.h

 public:
     OptionValuePathMappings (bool notify_changes) :
         OptionValue(),
         m_path_mappings (),
         m_notify_changes (notify_changes)
     {
     }
     
-    virtual 
-    ~OptionValuePathMappings()
+    ~OptionValuePathMappings() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypePathMap;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
     
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_path_mappings.Clear(m_notify_changes);
         m_value_was_set = false;
         return true;
     }
     
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
     
-    virtual bool
-    IsAggregateValue () const
+    bool
+    IsAggregateValue() const override
     {
         return true;
     }
 
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
     

     
 protected:
     PathMappingList m_path_mappings;
     bool m_notify_changes;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValuePathMappings_h_
+#endif // liblldb_OptionValuePathMappings_h_

lldb/trunk/include/lldb/Interpreter/OptionValueProperties.h

OptionValueProperties () :
         m_name_to_index ()
     {
     }
 
     OptionValueProperties (const ConstString &name);
 
     OptionValueProperties (const OptionValueProperties &global_properties);
     
-    virtual
-    ~OptionValueProperties()
+    ~OptionValueProperties() override
     {
     }
     
-    virtual Type
-    GetType () const
+    Type
+    GetType() const override
     {
         return eTypeProperties;
     }
     
-    virtual bool
-    Clear ();
+    bool
+    Clear() override;
 
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value, VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
 
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx,
-               Stream &strm,
-               uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx,
+        Stream &strm,
+        uint32_t dump_mask) override;
 
-    virtual ConstString
-    GetName () const
+    ConstString
+    GetName() const override
     {
         return m_name;
     }
     
     virtual Error
     DumpPropertyValue (const ExecutionContext *exe_ctx,
                        Stream &strm,
                        const char *property_path,
GetPropertyValueAtIndex (const ExecutionContext *exe_ctx,
                              uint32_t idx) const;
     
     virtual lldb::OptionValueSP
     GetValueForKey  (const ExecutionContext *exe_ctx,
                      const ConstString &key,
                      bool value_will_be_modified) const;
 
     lldb::OptionValueSP
-    GetSubValue (const ExecutionContext *exe_ctx,
-                 const char *name,
-                 bool value_will_be_modified,
-                 Error &error) const;
+    GetSubValue(const ExecutionContext *exe_ctx,
+    const char *name,
+    bool value_will_be_modified,
+    Error &error) const override;
 
-    virtual Error
-    SetSubValue (const ExecutionContext *exe_ctx,
-                 VarSetOperationType op,
-                 const char *path,
-                 const char *value);
+    Error
+    SetSubValue(const ExecutionContext *exe_ctx,
+    VarSetOperationType op,
+    const char *path,
+    const char *value) override;
 
     virtual bool
     PredicateMatches (const ExecutionContext *exe_ctx,
                       const char *predicate) const
     {
         return false;
     }
 
//    GetQualifiedName (Stream &strm);
     lldb::OptionValuePropertiesSP
     GetSubProperty (const ExecutionContext *exe_ctx,
                     const ConstString &name);
 
     void
     SetValueChangedCallback (uint32_t property_idx,
                              OptionValueChangedCallback callback,
                              void *baton);
+
 protected:
 
     Property *
     ProtectedGetPropertyAtIndex (uint32_t idx)
     {
         if (idx < m_properties.size())
             return &m_properties[idx];
         return NULL;
protected:
 
     ConstString m_name;
     std::vector<Property> m_properties;
     NameToIndex m_name_to_index;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueProperties_h_
+#endif // liblldb_OptionValueProperties_h_

lldb/trunk/include/lldb/Interpreter/OptionValueRegex.h

 {
 public:
     OptionValueRegex (const char *value = NULL) :
         OptionValue(),
         m_regex (value)
     {
     }
 
-    virtual 
-    ~OptionValueRegex()
+    ~OptionValueRegex() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypeRegex;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
 
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_regex.Clear();
         m_value_was_set = false;
         return true;
     }
 
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
 
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
     const RegularExpression *
     GetCurrentValue() const
     {
         if (m_regex.IsValid())
public:
     }
     
 protected:
     RegularExpression m_regex;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueRegex_h_
+#endif // liblldb_OptionValueRegex_h_

lldb/trunk/include/lldb/Interpreter/OptionValueSInt64.h

OptionValueSInt64 (const OptionValueSInt64 &rhs) :
         OptionValue(rhs),
         m_current_value (rhs.m_current_value),
         m_default_value (rhs.m_default_value),
         m_min_value (rhs.m_min_value),
         m_max_value (rhs.m_max_value)
     {
     }
 
-    virtual
-    ~OptionValueSInt64()
+    ~OptionValueSInt64() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypeSInt64;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
     
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;
     }
     
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
     
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
     
     const int64_t &
     operator = (int64_t value)
     {
protected:
     int64_t m_current_value;
     int64_t m_default_value;
     int64_t m_min_value;
     int64_t m_max_value;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueSInt64_h_
+#endif // liblldb_OptionValueSInt64_h_

lldb/trunk/include/lldb/Interpreter/OptionValueString.h

public:
     m_validator_baton(baton)
     {
         if  (current_value && current_value[0])
             m_current_value.assign (current_value);
         if  (default_value && default_value[0])
             m_default_value.assign (default_value);
     }
     
-    virtual
-    ~OptionValueString()
+    ~OptionValueString() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypeString;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
 
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;
     }
 
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
 
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
 
     Flags &
     GetOptions ()
     {
public:
     }
 
     bool
     IsDefaultValueEmpty () const
     {
         return m_default_value.empty();
     }
 
-    
 protected:
     std::string m_current_value;
     std::string m_default_value;
     Flags m_options;
     ValidatorCallback m_validator;
     void* m_validator_baton;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueString_h_
+#endif // liblldb_OptionValueString_h_

lldb/trunk/include/lldb/Interpreter/OptionValueUInt64.h

public:
     OptionValueUInt64 (uint64_t current_value,
                        uint64_t default_value) :
         OptionValue(),
         m_current_value (current_value),
         m_default_value (default_value)
     {
     }
     
-    virtual 
-    ~OptionValueUInt64()
+    ~OptionValueUInt64() override
     {
     }
     
     //---------------------------------------------------------------------
     // Decode a uint64_t from "value_cstr" return a OptionValueUInt64 object
     // inside of a lldb::OptionValueSP object if all goes well. If the 
     // string isn't a uint64_t value or any other error occurs, return an 
     // empty lldb::OptionValueSP and fill error in with the correct stuff.
     //---------------------------------------------------------------------
     static lldb::OptionValueSP
     Create (const char *value_cstr, Error &error);
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypeUInt64;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
     
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_current_value = m_default_value;
         m_value_was_set = false;
         return true;
     }
     
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
     
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
     
     const uint64_t &
     operator = (uint64_t value)
     {

     
 protected:
     uint64_t m_current_value;
     uint64_t m_default_value;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueUInt64_h_
+#endif // liblldb_OptionValueUInt64_h_

lldb/trunk/include/lldb/Interpreter/OptionValueUUID.h

public:
     }
     
     OptionValueUUID (const UUID &uuid) :
         OptionValue(),
         m_uuid (uuid)
     {
     }
     
-    virtual 
-    ~OptionValueUUID()
+    ~OptionValueUUID() override
     {
     }
     
     //---------------------------------------------------------------------
     // Virtual subclass pure virtual overrides
     //---------------------------------------------------------------------
     
-    virtual OptionValue::Type
-    GetType () const
+    OptionValue::Type
+    GetType() const override
     {
         return eTypeUUID;
     }
     
-    virtual void
-    DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask);
+    void
+    DumpValue(const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask) override;
     
-    virtual Error
-    SetValueFromString (llvm::StringRef value,
-                         VarSetOperationType op = eVarSetOperationAssign);
+    Error
+    SetValueFromString(llvm::StringRef value,
+           VarSetOperationType op = eVarSetOperationAssign) override;
     
-    virtual bool
-    Clear ()
+    bool
+    Clear() override
     {
         m_uuid.Clear();
         m_value_was_set = false;
         return true;
     }
     
-    virtual lldb::OptionValueSP
-    DeepCopy () const;
+    lldb::OptionValueSP
+    DeepCopy() const override;
     
     //---------------------------------------------------------------------
     // Subclass specific functions
     //---------------------------------------------------------------------
     
     UUID &
     GetCurrentValue()
     {
         return m_uuid;
     }
     
     const UUID &
     GetCurrentValue() const
     {
         return m_uuid;
     }
     
     void
     SetCurrentValue (const UUID &value)
     {
         m_uuid = value;
     }
     
-    virtual size_t
-    AutoComplete (CommandInterpreter &interpreter,
-                  const char *s,
-                  int match_start_point,
-                  int max_return_elements,
-                  bool &word_complete,
-                  StringList &matches);
+    size_t
+    AutoComplete(CommandInterpreter &interpreter,
+     const char *s,
+     int match_start_point,
+     int max_return_elements,
+     bool &word_complete,
+     StringList &matches) override;
 
 protected:
     UUID m_uuid;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionValueUUID_h_
+#endif // liblldb_OptionValueUUID_h_