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, 37 insertions, 40 deletions

diff --git a/lldb/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp b/lldb/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
index 1141b31ca1e..463e5f583c5 100644
--- a/lldb/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
+++ b/lldb/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
@@ -118,16 +118,14 @@ bool CommunicationKDP::SendRequestAndGetReply(
             }
           } else if (reply_sequence_id > request_sequence_id) {
             // Sequence ID was greater than the sequence ID of the packet we
-            // sent, something
-            // is really wrong...
+            // sent, something is really wrong...
             reply_packet.Clear();
             return false;
           } else {
-            // The reply sequence ID was less than our current packet's sequence
-            // ID
-            // so we should keep trying to get a response because this was a
-            // response
-            // for a previous packet that we must have retried.
+            // The reply sequence ID was less than our current packet's
+            // sequence ID so we should keep trying to get a response because
+            // this was a response for a previous packet that we must have
+            // retried.
           }
         } else {
           // Break and retry sending the packet as we didn't get a response due
@@ -315,9 +313,9 @@ bool CommunicationKDP::CheckForPacket(const uint8_t *src, size_t src_len,
       offset = 2;
       const uint16_t length = packet.GetU16(&offset);
       if (length <= bytes_available) {
-        // We have an entire packet ready, we need to copy the data
-        // bytes into a buffer that will be owned by the packet and
-        // erase the bytes from our communcation buffer "m_bytes"
+        // We have an entire packet ready, we need to copy the data bytes into
+        // a buffer that will be owned by the packet and erase the bytes from
+        // our communcation buffer "m_bytes"
         packet.SetData(DataBufferSP(new DataBufferHeap(&m_bytes[0], length)));
         m_bytes.erase(0, length);
 
@@ -332,8 +330,8 @@ bool CommunicationKDP::CheckForPacket(const uint8_t *src, size_t src_len,
     } break;
 
     default:
-      // Unrecognized reply command byte, erase this byte and try to get back on
-      // track
+      // Unrecognized reply command byte, erase this byte and try to get back
+      // on track
       if (log)
         log->Printf("CommunicationKDP::%s: tossing junk byte: 0x%2.2x",
                     __FUNCTION__, (uint8_t)m_bytes[0]);
@@ -1208,8 +1206,8 @@ uint32_t CommunicationKDP::SendRequestReadRegisters(uint32_t cpu,
       if (src) {
         ::memcpy(dst, src, bytes_to_copy);
         error.Clear();
-        // Return the number of bytes we could have returned regardless if
-        // we copied them or not, just so we know when things don't match up
+        // Return the number of bytes we could have returned regardless if we
+        // copied them or not, just so we know when things don't match up
         return src_len;
       }
     }
diff --git a/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp b/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
index f01f1ace583..40bebfcf098 100644
--- a/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
+++ b/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
@@ -172,10 +172,10 @@ ProcessKDP::ProcessKDP(TargetSP target_sp, ListenerSP listener_sp)
 //----------------------------------------------------------------------
 ProcessKDP::~ProcessKDP() {
   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();
 }
 
@@ -226,9 +226,9 @@ bool ProcessKDP::GetHostArchitecture(ArchSpec &arch) {
 Status ProcessKDP::DoConnectRemote(Stream *strm, llvm::StringRef remote_url) {
   Status error;
 
-  // Don't let any JIT happen when doing KDP as we can't allocate
-  // memory and we don't want to be mucking with threads that might
-  // already be handling exceptions
+  // Don't let any JIT happen when doing KDP as we can't allocate memory and we
+  // don't want to be mucking with threads that might already be handling
+  // exceptions
   SetCanJIT(false);
 
   if (remote_url.empty()) {
@@ -282,16 +282,15 @@ Status ProcessKDP::DoConnectRemote(Stream *strm, llvm::StringRef remote_url) {
 
           if (m_comm.RemoteIsEFI()) {
             // Select an invalid plugin name for the dynamic loader so one
-            // doesn't get used
-            // since EFI does its own manual loading via python scripting
+            // doesn't get used since EFI does its own manual loading via
+            // python scripting
             static ConstString g_none_dynamic_loader("none");
             m_dyld_plugin_name = g_none_dynamic_loader;
 
             if (kernel_uuid.IsValid()) {
-              // If EFI passed in a UUID= try to lookup UUID
-              // The slide will not be provided. But the UUID
-              // lookup will be used to launch EFI debug scripts
-              // from the dSYM, that can load all of the symbols.
+              // If EFI passed in a UUID= try to lookup UUID The slide will not
+              // be provided. But the UUID lookup will be used to launch EFI
+              // debug scripts from the dSYM, that can load all of the symbols.
               ModuleSpec module_spec;
               module_spec.GetUUID() = kernel_uuid;
               module_spec.GetArchitecture() = target.GetArchitecture();
@@ -443,8 +442,8 @@ Status ProcessKDP::DoResume() {
                   StateAsCString(thread_resume_state));
     switch (thread_resume_state) {
     case eStateSuspended:
-      // Nothing to do here when a thread will stay suspended
-      // we just leave the CPU mask bit set to zero for the thread
+      // Nothing to do here when a thread will stay suspended we just leave the
+      // CPU mask bit set to zero for the thread
       if (log)
         log->Printf("ProcessKDP::DoResume() = suspended???");
       break;
@@ -535,8 +534,8 @@ bool ProcessKDP::UpdateThreadList(ThreadList &old_thread_list,
 }
 
 void ProcessKDP::RefreshStateAfterStop() {
-  // Let all threads recover from stopping and do any clean up based
-  // on the previous thread state (if any).
+  // Let all threads recover from stopping and do any clean up based on the
+  // previous thread state (if any).
   m_thread_list.RefreshStateAfterStop();
 }
 
@@ -545,9 +544,9 @@ Status ProcessKDP::DoHalt(bool &caused_stop) {
 
   if (m_comm.IsRunning()) {
     if (m_destroy_in_process) {
-      // If we are attemping to destroy, we need to not return an error to
-      // Halt or DoDestroy won't get called.
-      // We are also currently running, so send a process stopped event
+      // If we are attemping to destroy, we need to not return an error to Halt
+      // or DoDestroy won't get called. We are also currently running, so send
+      // a process stopped event
       SetPrivateState(eStateStopped);
     } else {
       error.SetErrorString("KDP cannot interrupt a running kernel");
@@ -563,8 +562,8 @@ Status ProcessKDP::DoDetach(bool keep_stopped) {
     log->Printf("ProcessKDP::DoDetach(keep_stopped = %i)", keep_stopped);
 
   if (m_comm.IsRunning()) {
-    // We are running and we can't interrupt a running kernel, so we need
-    // to just close the connection to the kernel and hope for the best
+    // We are running and we can't interrupt a running kernel, so we need to
+    // just close the connection to the kernel and hope for the best
   } else {
     // If we are going to keep the target stopped, then don't send the
     // disconnect message.
diff --git a/lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp b/lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp
index 1902cc492ff..8aaacccf4c1 100644
--- a/lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp
+++ b/lldb/source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp
@@ -65,8 +65,8 @@ void ThreadKDP::RefreshStateAfterStop() {
   // context by the time this function gets called. The KDPRegisterContext
   // class has been made smart enough to detect when it needs to invalidate
   // which registers are valid by putting hooks in the register read and
-  // register supply functions where they check the process stop ID and do
-  // the right thing.
+  // register supply functions where they check the process stop ID and do the
+  // right thing.
   const bool force = false;
   lldb::RegisterContextSP reg_ctx_sp(GetRegisterContext());
   if (reg_ctx_sp)
@@ -151,8 +151,8 @@ void ThreadKDP::SetStopInfoFrom_KDP_EXCEPTION(
       const uint32_t exc_type = exc_reply_packet.GetU32(&offset);
       const uint32_t exc_code = exc_reply_packet.GetU32(&offset);
       const uint32_t exc_subcode = exc_reply_packet.GetU32(&offset);
-      // We have to make a copy of the stop info because the thread list
-      // will iterate through the threads and clear all stop infos..
+      // We have to make a copy of the stop info because the thread list will
+      // iterate through the threads and clear all stop infos..
 
       // Let the StopInfoMachException::CreateStopReasonWithMachException()
       // function update the PC if needed as we might hit a software breakpoint