[NFC] Remove ASCII lines from comments

A lot of comments in LLDB are surrounded by an ASCII line to delimit the
begging and end of the comment.

Its use is not really consistent across the code base, sometimes the
lines are longer, sometimes they are shorter and sometimes they are
omitted. Furthermore, it looks kind of weird with the 80 column limit,
where the comment actually extends past the line, but not by much.
Furthermore, when /// is used for Doxygen comments, it looks
particularly odd. And when // is used, it incorrectly gives the
impression that it's actually a Doxygen comment.

I assume these lines were added to improve distinguishing between
comments and code. However, given that todays editors and IDEs do a
great job at highlighting comments, I think it's worth to drop this for
the sake of consistency. The alternative is fixing all the
inconsistencies, which would create a lot more churn.

Differential revision: https://reviews.llvm.org/D60508

llvm-svn: 358135

14 files changed, 0 insertions, 92 deletions

diff --git a/lldb/source/Host/macosx/cfcpp/CFCBundle.cpp b/lldb/source/Host/macosx/cfcpp/CFCBundle.cpp
index 06057b5ed46..0ca2c00798f 100644
--- a/lldb/source/Host/macosx/cfcpp/CFCBundle.cpp
+++ b/lldb/source/Host/macosx/cfcpp/CFCBundle.cpp
@@ -9,9 +9,7 @@
 #include "CFCBundle.h"
 #include "CFCString.h"
 
-//----------------------------------------------------------------------
 // CFCBundle constructor
-//----------------------------------------------------------------------
 CFCBundle::CFCBundle(const char *path) : CFCReleaser<CFBundleRef>() {
   if (path && path[0])
     SetPath(path);
@@ -20,14 +18,10 @@ CFCBundle::CFCBundle(const char *path) : CFCReleaser<CFBundleRef>() {
 CFCBundle::CFCBundle(CFURLRef url)
     : CFCReleaser<CFBundleRef>(url ? CFBundleCreate(NULL, url) : NULL) {}
 
-//----------------------------------------------------------------------
 // Destructor
-//----------------------------------------------------------------------
 CFCBundle::~CFCBundle() {}
 
-//----------------------------------------------------------------------
 // Set the path for a bundle by supplying a
-//----------------------------------------------------------------------
 bool CFCBundle::SetPath(const char *path) {
   CFAllocatorRef alloc = kCFAllocatorDefault;
   // Release our old bundle and URL
diff --git a/lldb/source/Host/macosx/cfcpp/CFCBundle.h b/lldb/source/Host/macosx/cfcpp/CFCBundle.h
index 12516048f47..9ff58fba854 100644
--- a/lldb/source/Host/macosx/cfcpp/CFCBundle.h
+++ b/lldb/source/Host/macosx/cfcpp/CFCBundle.h
@@ -13,9 +13,7 @@
 
 class CFCBundle : public CFCReleaser<CFBundleRef> {
 public:
-  //------------------------------------------------------------------
   // Constructors and Destructors
-  //------------------------------------------------------------------
   CFCBundle(const char *path = NULL);
   CFCBundle(CFURLRef url);
 
diff --git a/lldb/source/Host/macosx/cfcpp/CFCData.cpp b/lldb/source/Host/macosx/cfcpp/CFCData.cpp
index c3deeca2ce9..191f4734c64 100644
--- a/lldb/source/Host/macosx/cfcpp/CFCData.cpp
+++ b/lldb/source/Host/macosx/cfcpp/CFCData.cpp
@@ -8,19 +8,13 @@
 
 #include "CFCData.h"
 
-//----------------------------------------------------------------------
 // CFCData constructor
-//----------------------------------------------------------------------
 CFCData::CFCData(CFDataRef data) : CFCReleaser<CFDataRef>(data) {}
 
-//----------------------------------------------------------------------
 // CFCData copy constructor
-//----------------------------------------------------------------------
 CFCData::CFCData(const CFCData &rhs) : CFCReleaser<CFDataRef>(rhs) {}
 
-//----------------------------------------------------------------------
 // CFCData copy constructor
-//----------------------------------------------------------------------
 CFCData &CFCData::operator=(const CFCData &rhs)
 
 {
@@ -29,9 +23,7 @@ CFCData &CFCData::operator=(const CFCData &rhs)
   return *this;
 }
 
-//----------------------------------------------------------------------
 // Destructor
-//----------------------------------------------------------------------
 CFCData::~CFCData() {}
 
 CFIndex CFCData::GetLength() const {
diff --git a/lldb/source/Host/macosx/cfcpp/CFCData.h b/lldb/source/Host/macosx/cfcpp/CFCData.h
index b0b25232b1c..33fcf53ed0b 100644
--- a/lldb/source/Host/macosx/cfcpp/CFCData.h
+++ b/lldb/source/Host/macosx/cfcpp/CFCData.h
@@ -13,9 +13,7 @@
 
 class CFCData : public CFCReleaser<CFDataRef> {
 public:
-  //------------------------------------------------------------------
   // Constructors and Destructors
-  //------------------------------------------------------------------
   CFCData(CFDataRef data = NULL);
   CFCData(const CFCData &rhs);
   CFCData &operator=(const CFCData &rhs);
@@ -26,9 +24,7 @@ public:
   CFIndex GetLength() const;
 
 protected:
-  //------------------------------------------------------------------
   // Classes that inherit from CFCData can see and modify these
-  //------------------------------------------------------------------
 };
 
 #endif // #ifndef CoreFoundationCPP_CFData_h_
diff --git a/lldb/source/Host/macosx/cfcpp/CFCMutableArray.cpp b/lldb/source/Host/macosx/cfcpp/CFCMutableArray.cpp
index 75bc12d28ff..a2172c296f6 100644
--- a/lldb/source/Host/macosx/cfcpp/CFCMutableArray.cpp
+++ b/lldb/source/Host/macosx/cfcpp/CFCMutableArray.cpp
@@ -9,24 +9,18 @@
 #include "CFCMutableArray.h"
 #include "CFCString.h"
 
-//----------------------------------------------------------------------
 // CFCString constructor
-//----------------------------------------------------------------------
 CFCMutableArray::CFCMutableArray(CFMutableArrayRef s)
     : CFCReleaser<CFMutableArrayRef>(s) {}
 
-//----------------------------------------------------------------------
 // CFCMutableArray copy constructor
-//----------------------------------------------------------------------
 CFCMutableArray::CFCMutableArray(const CFCMutableArray &rhs)
     : CFCReleaser<CFMutableArrayRef>(rhs) // NOTE: this won't make a copy of the
                                           // array, just add a new reference to
                                           // it
 {}
 
-//----------------------------------------------------------------------
 // CFCMutableArray copy constructor
-//----------------------------------------------------------------------
 CFCMutableArray &CFCMutableArray::operator=(const CFCMutableArray &rhs) {
   if (this != &rhs)
     *this = rhs; // NOTE: this operator won't make a copy of the array, just add
@@ -34,9 +28,7 @@ CFCMutableArray &CFCMutableArray::operator=(const CFCMutableArray &rhs) {
   return *this;
 }
 
-//----------------------------------------------------------------------
 // Destructor
-//----------------------------------------------------------------------
 CFCMutableArray::~CFCMutableArray() {}
 
 CFIndex CFCMutableArray::GetCount() const {
diff --git a/lldb/source/Host/macosx/cfcpp/CFCMutableArray.h b/lldb/source/Host/macosx/cfcpp/CFCMutableArray.h
index ba12301d1fd..46c5b912627 100644
--- a/lldb/source/Host/macosx/cfcpp/CFCMutableArray.h
+++ b/lldb/source/Host/macosx/cfcpp/CFCMutableArray.h
@@ -13,9 +13,7 @@
 
 class CFCMutableArray : public CFCReleaser<CFMutableArrayRef> {
 public:
-  //------------------------------------------------------------------
   // Constructors and Destructors
-  //------------------------------------------------------------------
   CFCMutableArray(CFMutableArrayRef array = NULL);
   CFCMutableArray(const CFCMutableArray &rhs); // This will copy the array
                                                // contents into a new array
diff --git a/lldb/source/Host/macosx/cfcpp/CFCMutableDictionary.cpp b/lldb/source/Host/macosx/cfcpp/CFCMutableDictionary.cpp
index 93094161382..66d572d2cfc 100644
--- a/lldb/source/Host/macosx/cfcpp/CFCMutableDictionary.cpp
+++ b/lldb/source/Host/macosx/cfcpp/CFCMutableDictionary.cpp
@@ -8,21 +8,15 @@
 
 #include "CFCMutableDictionary.h"
 #include "CFCString.h"
-//----------------------------------------------------------------------
 // CFCString constructor
-//----------------------------------------------------------------------
 CFCMutableDictionary::CFCMutableDictionary(CFMutableDictionaryRef s)
     : CFCReleaser<CFMutableDictionaryRef>(s) {}
 
-//----------------------------------------------------------------------
 // CFCMutableDictionary copy constructor
-//----------------------------------------------------------------------
 CFCMutableDictionary::CFCMutableDictionary(const CFCMutableDictionary &rhs)
     : CFCReleaser<CFMutableDictionaryRef>(rhs) {}
 
-//----------------------------------------------------------------------
 // CFCMutableDictionary copy constructor
-//----------------------------------------------------------------------
 const CFCMutableDictionary &CFCMutableDictionary::
 operator=(const CFCMutableDictionary &rhs) {
   if (this != &rhs)
@@ -30,9 +24,7 @@ operator=(const CFCMutableDictionary &rhs) {
   return *this;
 }
 
-//----------------------------------------------------------------------
 // Destructor
-//----------------------------------------------------------------------
 CFCMutableDictionary::~CFCMutableDictionary() {}
 
 CFIndex CFCMutableDictionary::GetCount() const {
diff --git a/lldb/source/Host/macosx/cfcpp/CFCMutableDictionary.h b/lldb/source/Host/macosx/cfcpp/CFCMutableDictionary.h
index 99849f4dd01..e9b494a5854 100644
--- a/lldb/source/Host/macosx/cfcpp/CFCMutableDictionary.h
+++ b/lldb/source/Host/macosx/cfcpp/CFCMutableDictionary.h
@@ -13,16 +13,12 @@
 
 class CFCMutableDictionary : public CFCReleaser<CFMutableDictionaryRef> {
 public:
-  //------------------------------------------------------------------
   // Constructors and Destructors
-  //------------------------------------------------------------------
   CFCMutableDictionary(CFMutableDictionaryRef s = NULL);
   CFCMutableDictionary(const CFCMutableDictionary &rhs);
   virtual ~CFCMutableDictionary();
 
-  //------------------------------------------------------------------
   // Operators
-  //------------------------------------------------------------------
   const CFCMutableDictionary &operator=(const CFCMutableDictionary &rhs);
 
   CFIndex GetCount() const;
@@ -61,14 +57,10 @@ public:
   CFMutableDictionaryRef Dictionary(bool can_create);
 
 protected:
-  //------------------------------------------------------------------
   // Classes that inherit from CFCMutableDictionary can see and modify these
-  //------------------------------------------------------------------
 
 private:
-  //------------------------------------------------------------------
   // For CFCMutableDictionary only
-  //------------------------------------------------------------------
 };
 
 #endif // CoreFoundationCPP_CFMutableDictionary_h_
diff --git a/lldb/source/Host/macosx/cfcpp/CFCMutableSet.cpp b/lldb/source/Host/macosx/cfcpp/CFCMutableSet.cpp
index bcfa7ce291d..a6517fafb00 100644
--- a/lldb/source/Host/macosx/cfcpp/CFCMutableSet.cpp
+++ b/lldb/source/Host/macosx/cfcpp/CFCMutableSet.cpp
@@ -9,30 +9,22 @@
 #include "CFCMutableSet.h"
 
 
-//----------------------------------------------------------------------
 // CFCString constructor
-//----------------------------------------------------------------------
 CFCMutableSet::CFCMutableSet(CFMutableSetRef s)
     : CFCReleaser<CFMutableSetRef>(s) {}
 
-//----------------------------------------------------------------------
 // CFCMutableSet copy constructor
-//----------------------------------------------------------------------
 CFCMutableSet::CFCMutableSet(const CFCMutableSet &rhs)
     : CFCReleaser<CFMutableSetRef>(rhs) {}
 
-//----------------------------------------------------------------------
 // CFCMutableSet copy constructor
-//----------------------------------------------------------------------
 const CFCMutableSet &CFCMutableSet::operator=(const CFCMutableSet &rhs) {
   if (this != &rhs)
     *this = rhs;
   return *this;
 }
 
-//----------------------------------------------------------------------
 // Destructor
-//----------------------------------------------------------------------
 CFCMutableSet::~CFCMutableSet() {}
 
 CFIndex CFCMutableSet::GetCount() const {
diff --git a/lldb/source/Host/macosx/cfcpp/CFCMutableSet.h b/lldb/source/Host/macosx/cfcpp/CFCMutableSet.h
index 5aabaffe664..a55d646be6e 100644
--- a/lldb/source/Host/macosx/cfcpp/CFCMutableSet.h
+++ b/lldb/source/Host/macosx/cfcpp/CFCMutableSet.h
@@ -13,16 +13,12 @@
 
 class CFCMutableSet : public CFCReleaser<CFMutableSetRef> {
 public:
-  //------------------------------------------------------------------
   // Constructors and Destructors
-  //------------------------------------------------------------------
   CFCMutableSet(CFMutableSetRef s = NULL);
   CFCMutableSet(const CFCMutableSet &rhs);
   virtual ~CFCMutableSet();
 
-  //------------------------------------------------------------------
   // Operators
-  //------------------------------------------------------------------
   const CFCMutableSet &operator=(const CFCMutableSet &rhs);
 
   CFIndex GetCount() const;
@@ -33,14 +29,10 @@ public:
   void RemoveAllValues();
 
 protected:
-  //------------------------------------------------------------------
   // Classes that inherit from CFCMutableSet can see and modify these
-  //------------------------------------------------------------------
 
 private:
-  //------------------------------------------------------------------
   // For CFCMutableSet only
-  //------------------------------------------------------------------
 };
 
 #endif // CoreFoundationCPP_CFMutableSet_h_
diff --git a/lldb/source/Host/macosx/cfcpp/CFCReleaser.h b/lldb/source/Host/macosx/cfcpp/CFCReleaser.h
index 816dba8813b..8a29f398021 100644
--- a/lldb/source/Host/macosx/cfcpp/CFCReleaser.h
+++ b/lldb/source/Host/macosx/cfcpp/CFCReleaser.h
@@ -15,7 +15,6 @@
 
 #include <assert.h>
 
-//----------------------------------------------------------------------
 // Templatized CF helper class that can own any CF pointer and will
 // call CFRelease() on any valid pointer it owns unless that pointer is
 // explicitly released using the release() member function. This class
@@ -24,42 +23,33 @@
 // CFCReleaser<T>::release() function won't actually CFRelease any owned
 // pointer, it is designed to relinquish ownership of the pointer just
 // like std:auto_ptr<T>::release() does.
-//----------------------------------------------------------------------
 template <class T> class CFCReleaser {
 public:
-  //----------------------------------------------------------
   // Constructor that takes a pointer to a CF object that is
   // to be released when this object goes out of scope
-  //----------------------------------------------------------
   CFCReleaser(T ptr = NULL) : _ptr(ptr) {}
 
-  //----------------------------------------------------------
   // Copy constructor
   //
   // Note that copying a CFCReleaser will not transfer
   // ownership of the contained pointer, but it will bump its
   // reference count. This is where this class differs from
   // std::auto_ptr.
-  //----------------------------------------------------------
   CFCReleaser(const CFCReleaser &rhs) : _ptr(rhs.get()) {
     if (get())
       ::CFRetain(get());
   }
 
-  //----------------------------------------------------------
   // The destructor will release the pointer that it contains
   // if it has a valid pointer.
-  //----------------------------------------------------------
   virtual ~CFCReleaser() { reset(); }
 
-  //----------------------------------------------------------
   // Assignment operator.
   //
   // Note that assigning one CFCReleaser to another will
   // not transfer ownership of the contained pointer, but it
   // will bump its reference count. This is where this class
   // differs from std::auto_ptr.
-  //----------------------------------------------------------
   CFCReleaser &operator=(const CFCReleaser<T> &rhs) {
     if (this != &rhs) {
       // Replace our owned pointer with the new one
@@ -71,7 +61,6 @@ public:
     return *this;
   }
 
-  //----------------------------------------------------------
   // Get the address of the contained type in case it needs
   // to be passed to a function that will fill in a pointer
   // value. The function currently will assert if _ptr is not
@@ -83,36 +72,29 @@ public:
   // sure any owned objects has CFRelease called on it.
   // I had to add the "enforce_null" bool here because some
   // API's require the pointer address even though they don't change it.
-  //----------------------------------------------------------
   T *ptr_address(bool enforce_null = true) {
     if (enforce_null)
       assert(_ptr == NULL);
     return &_ptr;
   }
 
-  //----------------------------------------------------------
   // Access the pointer itself
-  //----------------------------------------------------------
   T get() { return _ptr; }
 
   const T get() const { return _ptr; }
 
-  //----------------------------------------------------------
   // Set a new value for the pointer and CFRelease our old
   // value if we had a valid one.
-  //----------------------------------------------------------
   void reset(T ptr = NULL) {
     if ((_ptr != NULL) && (ptr != _ptr))
       ::CFRelease(_ptr);
     _ptr = ptr;
   }
 
-  //----------------------------------------------------------
   // Release ownership without calling CFRelease. This class
   // is designed to mimic std::auto_ptr<T>, so the release
   // method releases ownership of the contained pointer
   // and does NOT call CFRelease.
-  //----------------------------------------------------------
   T release() {
     T tmp = _ptr;
     _ptr = NULL;
diff --git a/lldb/source/Host/macosx/cfcpp/CFCString.cpp b/lldb/source/Host/macosx/cfcpp/CFCString.cpp
index a0768755f11..fbd33fc7224 100644
--- a/lldb/source/Host/macosx/cfcpp/CFCString.cpp
+++ b/lldb/source/Host/macosx/cfcpp/CFCString.cpp
@@ -10,19 +10,13 @@
 #include <glob.h>
 #include <string>
 
-//----------------------------------------------------------------------
 // CFCString constructor
-//----------------------------------------------------------------------
 CFCString::CFCString(CFStringRef s) : CFCReleaser<CFStringRef>(s) {}
 
-//----------------------------------------------------------------------
 // CFCString copy constructor
-//----------------------------------------------------------------------
 CFCString::CFCString(const CFCString &rhs) : CFCReleaser<CFStringRef>(rhs) {}
 
-//----------------------------------------------------------------------
 // CFCString copy constructor
-//----------------------------------------------------------------------
 CFCString &CFCString::operator=(const CFCString &rhs) {
   if (this != &rhs)
     *this = rhs;
@@ -37,9 +31,7 @@ CFCString::CFCString(const char *cstr, CFStringEncoding cstr_encoding)
   }
 }
 
-//----------------------------------------------------------------------
 // Destructor
-//----------------------------------------------------------------------
 CFCString::~CFCString() {}
 
 const char *CFCString::GetFileSystemRepresentation(std::string &s) {
diff --git a/lldb/source/Host/macosx/cfcpp/CFCString.h b/lldb/source/Host/macosx/cfcpp/CFCString.h
index 2ed860fa20f..300b1c4a413 100644
--- a/lldb/source/Host/macosx/cfcpp/CFCString.h
+++ b/lldb/source/Host/macosx/cfcpp/CFCString.h
@@ -15,9 +15,7 @@
 
 class CFCString : public CFCReleaser<CFStringRef> {
 public:
-  //------------------------------------------------------------------
   // Constructors and Destructors
-  //------------------------------------------------------------------
   CFCString(CFStringRef cf_str = NULL);
   CFCString(const char *s, CFStringEncoding encoding = kCFStringEncodingUTF8);
   CFCString(const CFCString &rhs);
diff --git a/lldb/source/Host/macosx/cfcpp/CoreFoundationCPP.h b/lldb/source/Host/macosx/cfcpp/CoreFoundationCPP.h
index 5a2e3996f10..0c2b82a34a3 100644
--- a/lldb/source/Host/macosx/cfcpp/CoreFoundationCPP.h
+++ b/lldb/source/Host/macosx/cfcpp/CoreFoundationCPP.h
@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//----------------------------------------------------------------------
 //
 //  CoreFoundationCPP.h
 //  CoreFoundationCPP
@@ -13,7 +12,6 @@
 //  Created by Greg Clayton on 4/23/09.
 //
 //
-//----------------------------------------------------------------------
 
 #ifndef CoreFoundationCPP_CoreFoundationCPP_H_
 #define CoreFoundationCPP_CoreFoundationCPP_H_