Reflow paragraphs in comments.

This is intended as a clean up after the big clang-format commit
(r280751), which unfortunately resulted in many of the comment
paragraphs in LLDB being very hard to read.

FYI, the script I used was:

import textwrap
import commands
import os
import sys
import re
tmp = "%s.tmp"%sys.argv[1]
out = open(tmp, "w+")
with open(sys.argv[1], "r") as f:
  header = ""
  text = ""
  comment = re.compile(r'^( *//) ([^ ].*)$')
  special = re.compile(r'^((([A-Z]+[: ])|([0-9]+ )).*)|(.*;)$')
  for line in f:
      match = comment.match(line)
      if match and not special.match(match.group(2)):
          # skip intentionally short comments.
          if not text and len(match.group(2)) < 40:
              out.write(line)
              continue

          if text:
              text += " " + match.group(2)
          else:
              header = match.group(1)
              text = match.group(2)

          continue

      if text:
          filled = textwrap.wrap(text, width=(78-len(header)),
                                 break_long_words=False)
          for l in filled:
              out.write(header+" "+l+'\n')
              text = ""

      out.write(line)

os.rename(tmp, sys.argv[1])

Differential Revision: https://reviews.llvm.org/D46144

llvm-svn: 331197

3 files changed, 29 insertions, 30 deletions

diff --git a/lldb/source/Plugins/Process/minidump/MinidumpParser.cpp b/lldb/source/Plugins/Process/minidump/MinidumpParser.cpp
index 36350fdb639..5aa04e3e123 100644
--- a/lldb/source/Plugins/Process/minidump/MinidumpParser.cpp
+++ b/lldb/source/Plugins/Process/minidump/MinidumpParser.cpp
@@ -115,12 +115,12 @@ MinidumpParser::GetThreadContext(const MinidumpThread &td) {
 
 llvm::ArrayRef<uint8_t>
 MinidumpParser::GetThreadContextWow64(const MinidumpThread &td) {
-  // On Windows, a 32-bit process can run on a 64-bit machine under
-  // WOW64. If the minidump was captured with a 64-bit debugger, then
-  // the CONTEXT we just grabbed from the mini_dump_thread is the one
-  // for the 64-bit "native" process rather than the 32-bit "guest"
-  // process we care about.  In this case, we can get the 32-bit CONTEXT
-  // from the TEB (Thread Environment Block) of the 64-bit process.
+  // On Windows, a 32-bit process can run on a 64-bit machine under WOW64. If
+  // the minidump was captured with a 64-bit debugger, then the CONTEXT we just
+  // grabbed from the mini_dump_thread is the one for the 64-bit "native"
+  // process rather than the 32-bit "guest" process we care about.  In this
+  // case, we can get the 32-bit CONTEXT from the TEB (Thread Environment
+  // Block) of the 64-bit process.
   auto teb_mem = GetMemory(td.teb, sizeof(TEB64));
   if (teb_mem.empty())
     return {};
@@ -130,9 +130,9 @@ MinidumpParser::GetThreadContextWow64(const MinidumpThread &td) {
   if (error.Fail())
     return {};
 
-  // Slot 1 of the thread-local storage in the 64-bit TEB points to a
-  // structure that includes the 32-bit CONTEXT (after a ULONG).
-  // See:  https://msdn.microsoft.com/en-us/library/ms681670.aspx
+  // Slot 1 of the thread-local storage in the 64-bit TEB points to a structure
+  // that includes the 32-bit CONTEXT (after a ULONG). See:
+  // https://msdn.microsoft.com/en-us/library/ms681670.aspx
   auto context =
       GetMemory(wow64teb->tls_slots[1] + 4, sizeof(MinidumpContext_x86_32));
   if (context.size() < sizeof(MinidumpContext_x86_32))
@@ -334,10 +334,10 @@ MinidumpParser::FindMemoryRange(lldb::addr_t addr) {
     }
   }
 
-  // Some Minidumps have a Memory64ListStream that captures all the heap
-  // memory (full-memory Minidumps).  We can't exactly use the same loop as
-  // above, because the Minidump uses slightly different data structures to
-  // describe those
+  // Some Minidumps have a Memory64ListStream that captures all the heap memory
+  // (full-memory Minidumps).  We can't exactly use the same loop as above,
+  // because the Minidump uses slightly different data structures to describe
+  // those
 
   if (!data64.empty()) {
     llvm::ArrayRef<MinidumpMemoryDescriptor64> memory64_list;
@@ -377,8 +377,8 @@ llvm::ArrayRef<uint8_t> MinidumpParser::GetMemory(lldb::addr_t addr,
     return {};
 
   // There's at least some overlap between the beginning of the desired range
-  // (addr) and the current range.  Figure out where the overlap begins and
-  // how much overlap there is.
+  // (addr) and the current range.  Figure out where the overlap begins and how
+  // much overlap there is.
 
   const size_t offset = addr - range->start;
 
diff --git a/lldb/source/Plugins/Process/minidump/MinidumpTypes.cpp b/lldb/source/Plugins/Process/minidump/MinidumpTypes.cpp
index 394a1ee7d2a..371049f74d6 100644
--- a/lldb/source/Plugins/Process/minidump/MinidumpTypes.cpp
+++ b/lldb/source/Plugins/Process/minidump/MinidumpTypes.cpp
@@ -55,10 +55,9 @@ lldb_private::minidump::parseMinidumpString(llvm::ArrayRef<uint8_t> &data) {
     return llvm::None;
 
   auto source_start = reinterpret_cast<const llvm::UTF16 *>(data.data());
-  // source_length is the length of the string in bytes
-  // we need the length of the string in UTF-16 characters/code points (16 bits
-  // per char)
-  // that's why it's divided by 2
+  // source_length is the length of the string in bytes we need the length of
+  // the string in UTF-16 characters/code points (16 bits per char) that's why
+  // it's divided by 2
   const auto source_end = source_start + source_length / 2;
   // resize to worst case length
   result.resize(UNI_MAX_UTF8_BYTES_PER_CODE_POINT * source_length / 2);
diff --git a/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp b/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp
index 44efc57c9a6..0f4f1236c4b 100644
--- a/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp
+++ b/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp
@@ -49,8 +49,8 @@ public:
   PlaceholderModule(const FileSpec &file_spec, const ArchSpec &arch) :
     Module(file_spec, arch) {}
 
-  // Creates a synthetic module section covering the whole module image
-  // (and sets the section load address as well)
+  // Creates a synthetic module section covering the whole module image (and
+  // sets the section load address as well)
   void CreateImageSection(const MinidumpModule *module, Target& target) {
     const ConstString section_name(".module_image");
     lldb::SectionSP section_sp(new Section(
@@ -137,10 +137,10 @@ ProcessMinidump::ProcessMinidump(lldb::TargetSP target_sp,
 
 ProcessMinidump::~ProcessMinidump() {
   Clear();
-  // We need to call finalize on the process before destroying ourselves
-  // to make sure all of the broadcaster cleanup goes as planned. If we
-  // destruct this class, then Process::~Process() might have problems
-  // trying to fully destroy the broadcaster.
+  // We need to call finalize on the process before destroying ourselves to
+  // make sure all of the broadcaster cleanup goes as planned. If we destruct
+  // this class, then Process::~Process() might have problems trying to fully
+  // destroy the broadcaster.
   Finalize();
 }
 
@@ -230,8 +230,8 @@ bool ProcessMinidump::WarnBeforeDetach() const { return false; }
 
 size_t ProcessMinidump::ReadMemory(lldb::addr_t addr, void *buf, size_t size,
                                    Status &error) {
-  // Don't allow the caching that lldb_private::Process::ReadMemory does
-  // since we have it all cached in our dump file anyway.
+  // Don't allow the caching that lldb_private::Process::ReadMemory does since
+  // we have it all cached in our dump file anyway.
   return DoReadMemory(addr, buf, size, error);
 }
 
@@ -327,9 +327,9 @@ void ProcessMinidump::ReadModuleList() {
     Status error;
     lldb::ModuleSP module_sp = GetTarget().GetSharedModule(module_spec, &error);
     if (!module_sp || error.Fail()) {
-      // We failed to locate a matching local object file. Fortunately,
-      // the minidump format encodes enough information about each module's
-      // memory range to allow us to create placeholder modules.
+      // We failed to locate a matching local object file. Fortunately, the
+      // minidump format encodes enough information about each module's memory
+      // range to allow us to create placeholder modules.
       //
       // This enables most LLDB functionality involving address-to-module
       // translations (ex. identifing the module for a stack frame PC) and