[LLDB] Fix Clang-tidy misc-use-override warnings in include/lldb/DataFormatters and include/lldb/Host, unify closing inclusion guards

[Eugene.Zelenko]

Summary

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

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

[labath]

Committed as r245279.

[Eugene.Zelenko]

Looks like closed status was overwritten by followed accepts.

lldb/trunk/include/lldb/DataFormatters/CXXFormatterFunctions.h

namespace formatters
         
         SyntheticChildrenFrontEnd* NSIndexPathSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
         
         class LibcxxVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             LibcxxVectorBoolSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
             
-            virtual size_t
-            CalculateNumChildren ();
+            size_t
+            CalculateNumChildren() override;
+            
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            bool
+            Update() override;
             
-            virtual bool
-            Update();
+            bool
+            MightHaveChildren() override;
             
-            virtual bool
-            MightHaveChildren ();
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
-            
-            virtual
-            ~LibcxxVectorBoolSyntheticFrontEnd ();
+            ~LibcxxVectorBoolSyntheticFrontEnd() override;
         private:
             CompilerType m_bool_type;
             ExecutionContextRef m_exe_ctx_ref;
             uint64_t m_count;
             lldb::addr_t m_base_data_address;
             std::map<size_t,lldb::ValueObjectSP> m_children;
         };
         
         SyntheticChildrenFrontEnd* LibcxxVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
         
         bool
         LibcxxContainerSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options);
         
         class LibstdcppMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             LibstdcppMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
             
-            virtual size_t
-            CalculateNumChildren ();
+            size_t
+            CalculateNumChildren() override;
             
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            Update();
+            bool
+            Update() override;
+            
+            bool
+            MightHaveChildren() override;
             
-            virtual bool
-            MightHaveChildren ();
+            size_t
+            GetIndexOfChildWithName (const ConstString &name) override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
-            
-            virtual
-            ~LibstdcppMapIteratorSyntheticFrontEnd ();
+            ~LibstdcppMapIteratorSyntheticFrontEnd() override;
         private:
             ExecutionContextRef m_exe_ctx_ref;
             lldb::addr_t m_pair_address;
             CompilerType m_pair_type;
             EvaluateExpressionOptions m_options;
             lldb::ValueObjectSP m_pair_sp;
         };
         
         SyntheticChildrenFrontEnd* LibstdcppMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
         
         class LibCxxMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             LibCxxMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
             
-            virtual size_t
-            CalculateNumChildren ();
+            size_t
+            CalculateNumChildren() override;
+            
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            bool
+            Update() override;
             
-            virtual bool
-            Update();
+            bool
+            MightHaveChildren() override;
             
-            virtual bool
-            MightHaveChildren ();
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
-            
-            virtual
-            ~LibCxxMapIteratorSyntheticFrontEnd ();
+            ~LibCxxMapIteratorSyntheticFrontEnd() override;
         private:
             ValueObject *m_pair_ptr;
         };
         
         SyntheticChildrenFrontEnd* LibCxxMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
 
         class VectorIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             VectorIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp,
                                              ConstString item_name);
             
-            virtual size_t
-            CalculateNumChildren ();
+            size_t
+            CalculateNumChildren() override;
             
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            Update();
+            bool
+            Update() override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            MightHaveChildren() override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
-            
-            virtual
-            ~VectorIteratorSyntheticFrontEnd ();
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
+            
+            ~VectorIteratorSyntheticFrontEnd() override;
         private:
             ExecutionContextRef m_exe_ctx_ref;
             ConstString m_item_name;
             lldb::ValueObjectSP m_item_sp;
         };
         
         SyntheticChildrenFrontEnd* LibCxxVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
         
         SyntheticChildrenFrontEnd* LibStdcppVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
         
         class LibcxxSharedPtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             LibcxxSharedPtrSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
             
-            virtual size_t
-            CalculateNumChildren ();
+            size_t
+            CalculateNumChildren() override;
             
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            Update();
+            bool
+            Update() override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            MightHaveChildren() override;
+            
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
-            
-            virtual
-            ~LibcxxSharedPtrSyntheticFrontEnd ();
+            ~LibcxxSharedPtrSyntheticFrontEnd() override;
         private:
             ValueObject* m_cntrl;
             lldb::ValueObjectSP m_count_sp;
             lldb::ValueObjectSP m_weak_count_sp;
             uint8_t m_ptr_size;
             lldb::ByteOrder m_byte_order;
         };
         

lldb/trunk/include/lldb/DataFormatters/FormatManager.h

#endif
     // this returns true if the ValueObjectPrinter is *highly encouraged*
     // to actually represent this ValueObject in one-liner format
     // If this object has a summary formatter, however, we should not
     // try and do one-lining, just let the summary do the right thing
     bool
     ShouldPrintAsOneLiner (ValueObject& valobj);
     
     void
-    Changed ()
+    Changed () override
     {
         ++m_last_revision;
         m_format_cache.Clear ();
     }
     
     uint32_t
-    GetCurrentRevision ()
+    GetCurrentRevision () override
     {
         return m_last_revision;
     }
     
-    ~FormatManager ()
+    ~FormatManager () override
     {
     }
     
     static FormattersMatchVector
     GetPossibleMatches (ValueObject& valobj,
                         lldb::DynamicValueType use_dynamic)
     {
         FormattersMatchVector matches;
private:
     LoadCoreMediaFormatters ();
     
     void
     LoadHardcodedFormatters ();
 };
     
 } // namespace lldb_private
     
-#endif  // lldb_FormatManager_h_
+#endif // lldb_FormatManager_h_

lldb/trunk/include/lldb/DataFormatters/TypeFormat.h

public:
         
         virtual ~TypeFormatImpl ();
         
         bool
         Cascades () const
         {
             return m_flags.GetCascades();
         }
+
         bool
         SkipsPointers () const
         {
             return m_flags.GetSkipPointers();
         }
+
         bool
         SkipsReferences () const
         {
             return m_flags.GetSkipReferences();
         }
+
         bool
         NonCacheable () const
         {
             return m_flags.GetNonCacheable();
         }
         
         void
         SetCascades (bool value)
namespace lldb_private {
     {
     public:
         TypeFormatImpl_Format (lldb::Format f = lldb::eFormatInvalid,
                                const TypeFormatImpl::Flags& flags = Flags());
         
         typedef std::shared_ptr<TypeFormatImpl_Format> SharedPointer;
         typedef bool(*ValueCallback)(void*, ConstString, const TypeFormatImpl_Format::SharedPointer&);
         
-        virtual ~TypeFormatImpl_Format ();
+        ~TypeFormatImpl_Format() override;
         
         lldb::Format
         GetFormat () const
         {
             return m_format;
         }
         
         void
         SetFormat (lldb::Format fmt)
         {
             m_format = fmt;
         }
         
-        virtual TypeFormatImpl::Type
-        GetType ()
+        TypeFormatImpl::Type
+        GetType() override
         {
             return TypeFormatImpl::Type::eTypeFormat;
         }
         
-        virtual bool
-        FormatObject (ValueObject *valobj,
-                      std::string& dest) const;
+        bool
+        FormatObject(ValueObject *valobj,
+         std::string& dest) const override;
         
-        virtual std::string
-        GetDescription();
+        std::string
+        GetDescription() override;
         
     protected:
         lldb::Format m_format;
         
     private:
         DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl_Format);
     };
     
     class TypeFormatImpl_EnumType : public TypeFormatImpl
     {
     public:
         TypeFormatImpl_EnumType (ConstString type_name = ConstString(""),
                                  const TypeFormatImpl::Flags& flags = Flags());
         
         typedef std::shared_ptr<TypeFormatImpl_EnumType> SharedPointer;
         typedef bool(*ValueCallback)(void*, ConstString, const TypeFormatImpl_EnumType::SharedPointer&);
         
-        ~TypeFormatImpl_EnumType ();
+        ~TypeFormatImpl_EnumType() override;
         
         ConstString
         GetTypeName ()
         {
             return m_enum_type;
         }
         
         void
         SetTypeName (ConstString enum_type)
         {
             m_enum_type = enum_type;
         }
         
-        virtual TypeFormatImpl::Type
-        GetType ()
+        TypeFormatImpl::Type
+        GetType() override
         {
             return TypeFormatImpl::Type::eTypeEnum;
         }
         
-        virtual bool
-        FormatObject (ValueObject *valobj,
-                      std::string& dest) const;
+        bool
+        FormatObject(ValueObject *valobj,
+         std::string& dest) const override;
         
-        virtual std::string
-        GetDescription();
+        std::string
+        GetDescription() override;
         
     protected:
         ConstString m_enum_type;
         mutable std::unordered_map<void*,CompilerType> m_types;
         
     private:
         DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl_EnumType);
     };
 } // namespace lldb_private
 
-#endif  // lldb_TypeFormat_h_
+#endif // lldb_TypeFormat_h_

lldb/trunk/include/lldb/DataFormatters/TypeSummary.h

namespace lldb_private {
     {
         std::string m_format_str;
         FormatEntity::Entry m_format;
         Error m_error;
         
         StringSummaryFormat(const TypeSummaryImpl::Flags& flags,
                             const char* f);
         
-        virtual
-        ~StringSummaryFormat()
+        ~StringSummaryFormat() override
         {
         }
 
         const char*
         GetSummaryString () const
         {
             return m_format_str.c_str();
         }
         
         void
         SetSummaryString (const char* f);
 
-        virtual bool
+        bool
         FormatObject(ValueObject *valobj,
                      std::string& dest,
-                     const TypeSummaryOptions& options);
+                     const TypeSummaryOptions& options) override;
         
-        virtual std::string
-        GetDescription();
+        std::string
+        GetDescription() override;
         
-        virtual bool
-        IsScripted ()
+        bool
+        IsScripted() override
         {
             return false;
         }
         
-        
-        virtual Type
-        GetType ()
+        Type
+        GetType() override
         {
             return TypeSummaryImpl::eTypeString;
         }
         
     private:
         DISALLOW_COPY_AND_ASSIGN(StringSummaryFormat);
     };
     
struct CXXFunctionSummaryFormat : public TypeSummaryImpl
         SetTextualInfo (const char* descr)
         {
             if (descr)
                 m_description.assign(descr);
             else
                 m_description.clear();
         }
         
-        virtual
-        ~CXXFunctionSummaryFormat ()
+        ~CXXFunctionSummaryFormat() override
         {
         }
         
-        virtual bool
-        FormatObject (ValueObject *valobj,
-                      std::string& dest,
-                      const TypeSummaryOptions& options);
+        bool
+        FormatObject(ValueObject *valobj,
+         std::string& dest,
+         const TypeSummaryOptions& options) override;
         
-        virtual std::string
-        GetDescription ();
+        std::string
+        GetDescription() override;
         
-        virtual bool
-        IsScripted ()
+        bool
+        IsScripted() override
         {
             return false;
         }
         
-        virtual Type
-        GetType ()
+        Type
+        GetType() override
         {
             return TypeSummaryImpl::eTypeCallback;
         }
         
         typedef std::shared_ptr<CXXFunctionSummaryFormat> SharedPointer;
         
     private:
         DISALLOW_COPY_AND_ASSIGN(CXXFunctionSummaryFormat);
struct ScriptSummaryFormat : public TypeSummaryImpl
         SetPythonScript (const char* script)
         {
             if (script)
                 m_python_script.assign(script);
             else
                 m_python_script.clear();
         }
         
-        virtual
-        ~ScriptSummaryFormat ()
+        ~ScriptSummaryFormat() override
         {
         }
         
-        virtual bool
-        FormatObject (ValueObject *valobj,
-                      std::string& dest,
-                      const TypeSummaryOptions& options);
+        bool
+        FormatObject(ValueObject *valobj,
+         std::string& dest,
+         const TypeSummaryOptions& options) override;
         
-        virtual std::string
-        GetDescription ();
+        std::string
+        GetDescription() override;
         
-        virtual bool
-        IsScripted ()
+        bool
+        IsScripted() override
         {
             return true;
         }
         
-        virtual Type
-        GetType ()
+        Type
+        GetType() override
         {
             return TypeSummaryImpl::eTypeScript;
         }
         
         typedef std::shared_ptr<ScriptSummaryFormat> SharedPointer;
         
-        
     private:
         DISALLOW_COPY_AND_ASSIGN(ScriptSummaryFormat);
     };
 #endif
 } // namespace lldb_private
 
-#endif  // lldb_TypeSummary_h_
+#endif // lldb_TypeSummary_h_

lldb/trunk/include/lldb/DataFormatters/TypeSynthetic.h

namespace lldb_private {
     
     class SyntheticValueProviderFrontEnd : public SyntheticChildrenFrontEnd
     {
     public:
         SyntheticValueProviderFrontEnd (ValueObject &backend) :
         SyntheticChildrenFrontEnd(backend)
         {}
         
-        virtual
-        ~SyntheticValueProviderFrontEnd ()
+        ~SyntheticValueProviderFrontEnd() override
         {
         }
         
-        virtual size_t
-        CalculateNumChildren () { return 0; }
+        size_t
+        CalculateNumChildren() override { return 0; }
         
-        virtual lldb::ValueObjectSP
-        GetChildAtIndex (size_t idx) { return nullptr; }
+        lldb::ValueObjectSP
+        GetChildAtIndex(size_t idx) override { return nullptr; }
         
-        virtual size_t
-        GetIndexOfChildWithName (const ConstString &name) { return UINT32_MAX; }
+        size_t
+        GetIndexOfChildWithName(const ConstString &name) override { return UINT32_MAX; }
         
-        virtual bool
-        Update () { return false; }
+        bool
+        Update() override { return false; }
         
-        virtual bool
-        MightHaveChildren () { return false; }
+        bool
+        MightHaveChildren () override { return false; }
         
-        virtual lldb::ValueObjectSP
-        GetSyntheticValue () = 0;
+        lldb::ValueObjectSP
+        GetSyntheticValue() override = 0;
         
     private:
         DISALLOW_COPY_AND_ASSIGN(SyntheticValueProviderFrontEnd);
     };
     
     class SyntheticChildren
     {
     public:
public:
         
         void
         AddExpressionPath (const std::string& path);
         
         bool
         SetExpressionPathAtIndex (size_t i, const std::string& path);
         
         bool
-        IsScripted ()
+        IsScripted() override
         {
             return false;
         }
         
         std::string
-        GetDescription ();
+        GetDescription() override;
         
         class FrontEnd : public SyntheticChildrenFrontEnd
         {
         private:
             TypeFilterImpl* filter;
         public:
             
             FrontEnd(TypeFilterImpl* flt,
                      ValueObject &backend) :
             SyntheticChildrenFrontEnd(backend),
             filter(flt)
             {}
             
-            virtual
-            ~FrontEnd ()
+            ~FrontEnd() override
             {
             }
             
-            virtual size_t
-            CalculateNumChildren ()
+            size_t
+            CalculateNumChildren() override
             {
                 return filter->GetCount();
             }
             
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx)
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override
             {
                 if (idx >= filter->GetCount())
                     return lldb::ValueObjectSP();
                 return m_backend.GetSyntheticExpressionPathChild(filter->GetExpressionPathAtIndex(idx), true);
             }
             
-            virtual bool
-            Update() { return false; }
+            bool
+            Update() override { return false; }
             
-            virtual bool
-            MightHaveChildren ()
+            bool
+            MightHaveChildren() override
             {
                 return filter->GetCount() > 0;
             }
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
             
             typedef std::shared_ptr<SyntheticChildrenFrontEnd> SharedPointer;
             
         private:
             DISALLOW_COPY_AND_ASSIGN(FrontEnd);
         };
         
-        virtual SyntheticChildrenFrontEnd::AutoPointer
-        GetFrontEnd(ValueObject &backend)
+        SyntheticChildrenFrontEnd::AutoPointer
+        GetFrontEnd(ValueObject &backend) override
         {
             return SyntheticChildrenFrontEnd::AutoPointer(new FrontEnd(this, backend));
         }
         
     private:
         DISALLOW_COPY_AND_ASSIGN(TypeFilterImpl);
     };
     
public:
                               CreateFrontEndCallback callback) :
         SyntheticChildren(flags),
         m_create_callback(callback),
         m_description(description ? description : "")
         {
         }
         
         bool
-        IsScripted ()
+        IsScripted() override
         {
             return false;
         }
         
         std::string
-        GetDescription ();
+        GetDescription() override;
         
-        virtual SyntheticChildrenFrontEnd::AutoPointer
-        GetFrontEnd (ValueObject &backend)
+        SyntheticChildrenFrontEnd::AutoPointer
+        GetFrontEnd(ValueObject &backend) override
         {
             return SyntheticChildrenFrontEnd::AutoPointer(m_create_callback(this, backend.GetSP()));
         }
         
     private:
         DISALLOW_COPY_AND_ASSIGN(CXXSyntheticChildren);
     };
     
public:
         
         void
         SetPythonCode (const char* script)
         {
             m_python_code.assign(script);
         }
         
         std::string
-        GetDescription ();
+        GetDescription() override;
         
         bool
-        IsScripted ()
+        IsScripted() override
         {
             return true;
         }
         
         class FrontEnd : public SyntheticChildrenFrontEnd
         {
         private:
             std::string m_python_class;
             StructuredData::ObjectSP m_wrapper_sp;
             ScriptInterpreter *m_interpreter;
         public:
             
             FrontEnd (std::string pclass,
                       ValueObject &backend);
             
             bool
             IsValid ();
             
-            virtual
-            ~FrontEnd ();
+            ~FrontEnd() override;
             
-            virtual size_t
-            CalculateNumChildren ();
+            size_t
+            CalculateNumChildren() override;
             
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            Update ();
+            bool
+            Update() override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            MightHaveChildren() override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
             
-            virtual lldb::ValueObjectSP
-            GetSyntheticValue ();
+            lldb::ValueObjectSP
+            GetSyntheticValue() override;
             
             typedef std::shared_ptr<SyntheticChildrenFrontEnd> SharedPointer;
             
         private:
             DISALLOW_COPY_AND_ASSIGN(FrontEnd);
         };
         
-        virtual SyntheticChildrenFrontEnd::AutoPointer
-        GetFrontEnd(ValueObject &backend)
+        SyntheticChildrenFrontEnd::AutoPointer
+        GetFrontEnd(ValueObject &backend) override
         {
             auto synth_ptr = SyntheticChildrenFrontEnd::AutoPointer(new FrontEnd(m_python_class, backend));
             if (synth_ptr && ((FrontEnd*)synth_ptr.get())->IsValid())
                 return synth_ptr;
             return NULL;
         }
         
     private:
         DISALLOW_COPY_AND_ASSIGN(ScriptedSyntheticChildren);
     };
 #endif
 } // namespace lldb_private
 
-#endif  // lldb_TypeSynthetic_h_
+#endif // lldb_TypeSynthetic_h_

lldb/trunk/include/lldb/DataFormatters/TypeValidator.h

 public:
     typedef std::function<TypeValidatorImpl::ValidationResult(ValueObject* valobj)> ValidatorFunction;
     
     TypeValidatorImpl_CXX (ValidatorFunction f, std::string d, const TypeValidatorImpl::Flags& flags = Flags());
     
     typedef std::shared_ptr<TypeValidatorImpl_CXX> SharedPointer;
     typedef bool(*ValueCallback)(void*, ConstString, const TypeValidatorImpl_CXX::SharedPointer&);
     
-    virtual ~TypeValidatorImpl_CXX ();
+    ~TypeValidatorImpl_CXX() override;
     
     ValidatorFunction
     GetValidatorFunction () const
     {
         return m_validator_function;
     }
     
     void
     SetValidatorFunction (ValidatorFunction f)
     {
         m_validator_function = f;
     }
     
-    virtual TypeValidatorImpl::Type
-    GetType ()
+    TypeValidatorImpl::Type
+    GetType() override
     {
         return TypeValidatorImpl::Type::eTypeCXX;
     }
     
-    virtual ValidationResult
-    FormatObject (ValueObject *valobj) const;
+    ValidationResult
+    FormatObject(ValueObject *valobj) const override;
     
-    virtual std::string
-    GetDescription();
+    std::string
+    GetDescription() override;
     
 protected:
     std::string m_description;
     ValidatorFunction m_validator_function;
     
 private:
     DISALLOW_COPY_AND_ASSIGN(TypeValidatorImpl_CXX);
 };
 
     
 } // namespace lldb_private
 
-#endif  // lldb_TypeValidator_h_
+#endif // lldb_TypeValidator_h_

lldb/trunk/include/lldb/Host/File.h

 //===-- File.h --------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_File_h_
 #define liblldb_File_h_
-#if defined(__cplusplus)
 
 #include <stdarg.h>
 #include <stdio.h>
 #include <sys/types.h>
 
 #include "lldb/lldb-private.h"
 #include "lldb/Host/IOObject.h"
 
public:
     {
     }
 
     //------------------------------------------------------------------
     /// Destructor.
     ///
     /// The destructor is virtual in case this class is subclassed.
     //------------------------------------------------------------------
-    virtual
-    ~File ();
+    ~File() override;
 
     bool
-    IsValid () const
+    IsValid() const override
     {
         return DescriptorIsValid() || StreamIsValid();
     }
 
     //------------------------------------------------------------------
     /// Convert to pointer operator.
     ///
     /// This allows code to check a File object to see if it
public:
     ///     Options to use when opening (see File::Permissions)
     //------------------------------------------------------------------
     Error
     Open (const char *path,
           uint32_t options,
           uint32_t permissions = lldb::eFilePermissionsFileDefault);
 
     Error
-    Close ();
+    Close() override;
     
     Error
     Duplicate (const File &rhs);
 
     int
     GetDescriptor() const;
 
     WaitableHandle
-    GetWaitableHandle();
-
+    GetWaitableHandle() override;
 
     void
     SetDescriptor(int fd, bool transfer_ownership);
 
     FILE *
     GetStream ();
 
     void
public:
     ///     The number of bytes to read form the current file position
     ///     which gets modified with the number of bytes that were read.
     ///
     /// @return
     ///     An error object that indicates success or the reason for 
     ///     failure.
     //------------------------------------------------------------------
     Error
-    Read (void *buf, size_t &num_bytes);
+    Read(void *buf, size_t &num_bytes) override;
           
     //------------------------------------------------------------------
     /// Write bytes to a file at the current file position.
     ///
     /// NOTE: This function is NOT thread safe. Use the write function
     /// that takes an "off_t &offset" to ensure correct operation in
     /// multi-threaded environments.
     ///
     /// @param[in] buf
     ///     A buffer where to put the bytes that are read.
     ///
     /// @param[in,out] num_bytes
     ///     The number of bytes to write to the current file position
     ///     which gets modified with the number of bytes that were 
     ///     written.
     ///
     /// @return
     ///     An error object that indicates success or the reason for 
     ///     failure.
     //------------------------------------------------------------------
     Error
-    Write (const void *buf, size_t &num_bytes);
+    Write(const void *buf, size_t &num_bytes) override;
 
     //------------------------------------------------------------------
     /// Seek to an offset relative to the beginning of the file.
     ///
     /// NOTE: This function is NOT thread safe, other threads that 
     /// access this object might also change the current file position.
     /// For thread safe reads and writes see the following functions:
     /// @see File::Read (void *, size_t, off_t &)
protected:
     uint32_t m_options;
     bool m_own_stream;
     LazyBool m_is_interactive;
     LazyBool m_is_real_terminal;
 };
 
 } // namespace lldb_private
 
-#endif  // #if defined(__cplusplus)
-#endif  // liblldb_File_h_
+#endif // liblldb_File_h_

lldb/trunk/include/lldb/Host/Socket.h

typedef enum
         ProtocolTcp,
         ProtocolUdp,
         ProtocolUnixDomain
     } SocketProtocol;
 
     static const NativeSocket kInvalidSocketValue;
 
     Socket(NativeSocket socket, SocketProtocol protocol, bool should_close);
-    ~Socket();
+    ~Socket() override;
 
     // Initialize a Tcp Socket object in listening mode.  listen and accept are implemented
     // separately because the caller may wish to manipulate or query the socket after it is
     // initialized, but before entering a blocking accept.
     static Error TcpListen(
         llvm::StringRef host_and_port,
         bool child_processes_inherit,
         Socket *&socket,
public:
 
     // must be connected
     // returns ip address string or empty string if error
     std::string GetRemoteIPAddress () const;
 
     NativeSocket GetNativeSocket () const { return m_socket; }
     SocketProtocol GetSocketProtocol () const { return m_protocol; }
 
-    virtual Error Read (void *buf, size_t &num_bytes);
-    virtual Error Write (const void *buf, size_t &num_bytes);
+    Error Read (void *buf, size_t &num_bytes) override;
+    Error Write (const void *buf, size_t &num_bytes) override;
 
     virtual Error PreDisconnect ();
-    virtual Error Close ();
+    Error Close() override;
 
-    virtual bool IsValid () const { return m_socket != kInvalidSocketValue; }
-    virtual WaitableHandle GetWaitableHandle ();
+    bool IsValid () const override { return m_socket != kInvalidSocketValue; }
+    WaitableHandle GetWaitableHandle () override;
 
     static bool
     DecodeHostAndPort (llvm::StringRef host_and_port, 
                        std::string &host_str, 
                        std::string &port_str, 
                        int32_t& port,
                        Error *error_ptr);
 
 protected:
     SocketProtocol m_protocol;
     NativeSocket m_socket;
     SocketAddress m_udp_send_sockaddr;    // Send address used for UDP connections.
 };
-}
 
-#endif
+} // namespace lldb_private
+
+#endif // liblldb_Host_Socket_h_

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

 {
   public:
     ConnectionFileDescriptor(bool child_processes_inherit = false);
 
     ConnectionFileDescriptor(int fd, bool owns_fd);
 
     ConnectionFileDescriptor(Socket* socket);
 
-    virtual ~ConnectionFileDescriptor();
+    ~ConnectionFileDescriptor() override;
 
     bool IsConnected() const override;
 
     lldb::ConnectionStatus Connect(const char *s, Error *error_ptr) override;
 
     lldb::ConnectionStatus Disconnect(Error *error_ptr) override;
 
     size_t Read(void *dst, size_t dst_len, uint32_t timeout_usec, lldb::ConnectionStatus &status, Error *error_ptr) override;

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

 
 class HostThreadPosix : public HostNativeThreadBase
 {
     DISALLOW_COPY_AND_ASSIGN(HostThreadPosix);
 
   public:
     HostThreadPosix();
     HostThreadPosix(lldb::thread_t thread);
-    virtual ~HostThreadPosix();
+    ~HostThreadPosix() override;
 
     Error Join(lldb::thread_result_t *result) override;
     Error Cancel() override;
 
     Error Detach();
 };
-}
 
-#endif
+} // namespace lldb_private
+
+#endif // lldb_Host_posix_HostThreadPosix_h_

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

 #include "lldb/Host/LockFileBase.h"
 
 namespace lldb_private {
 
 class LockFilePosix : public LockFileBase
 {
 public:
     explicit LockFilePosix (int fd);
-    ~LockFilePosix ();
+    ~LockFilePosix () override;
 
 protected:
     Error
     DoWriteLock (const uint64_t start, const uint64_t len) override;
 
     Error
     DoTryWriteLock (const uint64_t start, const uint64_t len) override;
 
     Error
     DoReadLock (const uint64_t start, const uint64_t len) override;
 
     Error
     DoTryReadLock (const uint64_t start, const uint64_t len) override;
 
     Error
     DoUnlock () override;
 };
 
-}  // namespace lldb_private
+} // namespace lldb_private
 
-#endif  // liblldb_Host_posix_LockFilePosix_h_
+#endif // liblldb_Host_posix_LockFilePosix_h_