*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 182 insertions, 231 deletions

diff --git a/lldb/source/Utility/SelectHelper.cpp b/lldb/source/Utility/SelectHelper.cpp
index 44282d2..cd9a0f6 100644
--- a/lldb/source/Utility/SelectHelper.cpp
+++ b/lldb/source/Utility/SelectHelper.cpp
@@ -32,269 +32,220 @@
 
 // Project includes
 #include "lldb/Core/Error.h"
-#include "lldb/Utility/SelectHelper.h"
 #include "lldb/Utility/LLDBAssert.h"
+#include "lldb/Utility/SelectHelper.h"
 
-SelectHelper::SelectHelper() :
-    m_fd_map(),
-    m_end_time() // Infinite timeout unless SelectHelper::SetTimeout() gets called
-{
-}
+SelectHelper::SelectHelper()
+    : m_fd_map(), m_end_time() // Infinite timeout unless
+                               // SelectHelper::SetTimeout() gets called
+{}
 
-void
-SelectHelper::SetTimeout(const std::chrono::microseconds &timeout)
-{
-    using namespace std::chrono;
-    m_end_time = steady_clock::time_point(steady_clock::now() + timeout);
+void SelectHelper::SetTimeout(const std::chrono::microseconds &timeout) {
+  using namespace std::chrono;
+  m_end_time = steady_clock::time_point(steady_clock::now() + timeout);
 }
 
-void
-SelectHelper::FDSetRead(int fd)
-{
-    m_fd_map[fd].read_set = true;
-}
+void SelectHelper::FDSetRead(int fd) { m_fd_map[fd].read_set = true; }
 
-void
-SelectHelper::FDSetWrite(int fd)
-{
-    m_fd_map[fd].write_set = true;
-}
+void SelectHelper::FDSetWrite(int fd) { m_fd_map[fd].write_set = true; }
 
-void
-SelectHelper::FDSetError(int fd)
-{
-    m_fd_map[fd].error_set = true;
-}
+void SelectHelper::FDSetError(int fd) { m_fd_map[fd].error_set = true; }
 
-bool
-SelectHelper::FDIsSetRead(int fd) const
-{
-    auto pos = m_fd_map.find(fd);
-    if (pos != m_fd_map.end())
-        return pos->second.read_is_set;
-    else
-        return false;
+bool SelectHelper::FDIsSetRead(int fd) const {
+  auto pos = m_fd_map.find(fd);
+  if (pos != m_fd_map.end())
+    return pos->second.read_is_set;
+  else
+    return false;
 }
 
-bool
-SelectHelper::FDIsSetWrite(int fd) const
-{
-    auto pos = m_fd_map.find(fd);
-    if (pos != m_fd_map.end())
-        return pos->second.write_is_set;
-    else
-        return false;
+bool SelectHelper::FDIsSetWrite(int fd) const {
+  auto pos = m_fd_map.find(fd);
+  if (pos != m_fd_map.end())
+    return pos->second.write_is_set;
+  else
+    return false;
 }
 
-bool
-SelectHelper::FDIsSetError(int fd) const
-{
-    auto pos = m_fd_map.find(fd);
-    if (pos != m_fd_map.end())
-        return pos->second.error_is_set;
-    else
-        return false;
+bool SelectHelper::FDIsSetError(int fd) const {
+  auto pos = m_fd_map.find(fd);
+  if (pos != m_fd_map.end())
+    return pos->second.error_is_set;
+  else
+    return false;
 }
 
-lldb_private::Error
-SelectHelper::Select()
-{
-    lldb_private::Error error;
+lldb_private::Error SelectHelper::Select() {
+  lldb_private::Error error;
 #ifdef _MSC_VER
-    // On windows FD_SETSIZE limits the number of file descriptors, not their numeric value.
-    lldbassert(m_fd_map.size() <= FD_SETSIZE);
-    if (m_fd_map.size() > FD_SETSIZE)
-        return lldb_private::Error("Too many file descriptors for select()");
+  // On windows FD_SETSIZE limits the number of file descriptors, not their
+  // numeric value.
+  lldbassert(m_fd_map.size() <= FD_SETSIZE);
+  if (m_fd_map.size() > FD_SETSIZE)
+    return lldb_private::Error("Too many file descriptors for select()");
 #endif
 
-    int max_read_fd = -1;
-    int max_write_fd = -1;
-    int max_error_fd = -1;
-    int max_fd = -1;
-    for (auto &pair : m_fd_map)
-    {
-        pair.second.PrepareForSelect();
-        const int fd = pair.first;
+  int max_read_fd = -1;
+  int max_write_fd = -1;
+  int max_error_fd = -1;
+  int max_fd = -1;
+  for (auto &pair : m_fd_map) {
+    pair.second.PrepareForSelect();
+    const int fd = pair.first;
 #if !defined(__APPLE__) && !defined(_MSC_VER)
-        lldbassert(fd < FD_SETSIZE);
-        if (fd >= FD_SETSIZE)
-        {
-            error.SetErrorStringWithFormat("%i is too large for select()", fd);
-            return error;
-        }
+    lldbassert(fd < FD_SETSIZE);
+    if (fd >= FD_SETSIZE) {
+      error.SetErrorStringWithFormat("%i is too large for select()", fd);
+      return error;
+    }
 #endif
-        if (pair.second.read_set)
-        {
-            max_read_fd = std::max<int>(fd, max_read_fd);
-            max_fd = std::max<int>(fd, max_fd);
-        }
-        if (pair.second.write_set)
-        {
-            max_write_fd = std::max<int>(fd, max_write_fd);
-            max_fd = std::max<int>(fd, max_fd);
-        }
-        if (pair.second.error_set)
-        {
-            max_error_fd = std::max<int>(fd, max_error_fd);
-            max_fd = std::max<int>(fd, max_fd);
-        }
+    if (pair.second.read_set) {
+      max_read_fd = std::max<int>(fd, max_read_fd);
+      max_fd = std::max<int>(fd, max_fd);
     }
-
-    if (max_fd == -1)
-    {
-        error.SetErrorString("no valid file descriptors");
-        return error;
+    if (pair.second.write_set) {
+      max_write_fd = std::max<int>(fd, max_write_fd);
+      max_fd = std::max<int>(fd, max_fd);
+    }
+    if (pair.second.error_set) {
+      max_error_fd = std::max<int>(fd, max_error_fd);
+      max_fd = std::max<int>(fd, max_fd);
     }
+  }
 
-    const int nfds = max_fd + 1;
-    fd_set *read_fdset_ptr = nullptr;
-    fd_set *write_fdset_ptr = nullptr;
-    fd_set *error_fdset_ptr = nullptr;
-    //----------------------------------------------------------------------
-    // Initialize and zero out the fdsets
-    //----------------------------------------------------------------------
+  if (max_fd == -1) {
+    error.SetErrorString("no valid file descriptors");
+    return error;
+  }
+
+  const int nfds = max_fd + 1;
+  fd_set *read_fdset_ptr = nullptr;
+  fd_set *write_fdset_ptr = nullptr;
+  fd_set *error_fdset_ptr = nullptr;
+//----------------------------------------------------------------------
+// Initialize and zero out the fdsets
+//----------------------------------------------------------------------
 #if defined(__APPLE__)
-    llvm::SmallVector<fd_set, 1> read_fdset;
-    llvm::SmallVector<fd_set, 1> write_fdset;
-    llvm::SmallVector<fd_set, 1> error_fdset;
-
-    if (max_read_fd >= 0)
-    {
-        read_fdset.resize((nfds / FD_SETSIZE) + 1);
-        read_fdset_ptr = read_fdset.data();
-    }
-    if (max_write_fd >= 0)
-    {
-        write_fdset.resize((nfds / FD_SETSIZE) + 1);
-        write_fdset_ptr = write_fdset.data();
-    }
-    if (max_error_fd >= 0)
-    {
-        error_fdset.resize((nfds / FD_SETSIZE) + 1);
-        error_fdset_ptr = error_fdset.data();
-    }
-    for (auto &fd_set : read_fdset)
-        FD_ZERO(&fd_set);
-    for (auto &fd_set : write_fdset)
-        FD_ZERO(&fd_set);
-    for (auto &fd_set : error_fdset)
-        FD_ZERO(&fd_set);
+  llvm::SmallVector<fd_set, 1> read_fdset;
+  llvm::SmallVector<fd_set, 1> write_fdset;
+  llvm::SmallVector<fd_set, 1> error_fdset;
+
+  if (max_read_fd >= 0) {
+    read_fdset.resize((nfds / FD_SETSIZE) + 1);
+    read_fdset_ptr = read_fdset.data();
+  }
+  if (max_write_fd >= 0) {
+    write_fdset.resize((nfds / FD_SETSIZE) + 1);
+    write_fdset_ptr = write_fdset.data();
+  }
+  if (max_error_fd >= 0) {
+    error_fdset.resize((nfds / FD_SETSIZE) + 1);
+    error_fdset_ptr = error_fdset.data();
+  }
+  for (auto &fd_set : read_fdset)
+    FD_ZERO(&fd_set);
+  for (auto &fd_set : write_fdset)
+    FD_ZERO(&fd_set);
+  for (auto &fd_set : error_fdset)
+    FD_ZERO(&fd_set);
 #else
-    fd_set read_fdset;
-    fd_set write_fdset;
-    fd_set error_fdset;
-
-    if (max_read_fd >= 0)
-    {
-        FD_ZERO(&read_fdset);
-        read_fdset_ptr = &read_fdset;
-    }
-    if (max_write_fd >= 0)
-    {
-        FD_ZERO(&write_fdset);
-        write_fdset_ptr = &write_fdset;
-    }
-    if (max_error_fd >= 0)
-    {
-        FD_ZERO(&error_fdset);
-        error_fdset_ptr = &error_fdset;
-    }
+  fd_set read_fdset;
+  fd_set write_fdset;
+  fd_set error_fdset;
+
+  if (max_read_fd >= 0) {
+    FD_ZERO(&read_fdset);
+    read_fdset_ptr = &read_fdset;
+  }
+  if (max_write_fd >= 0) {
+    FD_ZERO(&write_fdset);
+    write_fdset_ptr = &write_fdset;
+  }
+  if (max_error_fd >= 0) {
+    FD_ZERO(&error_fdset);
+    error_fdset_ptr = &error_fdset;
+  }
 #endif
-    //----------------------------------------------------------------------
-    // Set the FD bits in the fdsets for read/write/error
-    //----------------------------------------------------------------------
-    for (auto &pair : m_fd_map)
-    {
-        const int fd = pair.first;
+  //----------------------------------------------------------------------
+  // Set the FD bits in the fdsets for read/write/error
+  //----------------------------------------------------------------------
+  for (auto &pair : m_fd_map) {
+    const int fd = pair.first;
 
-        if (pair.second.read_set)
-            FD_SET(fd, read_fdset_ptr);
+    if (pair.second.read_set)
+      FD_SET(fd, read_fdset_ptr);
 
-        if (pair.second.write_set)
-            FD_SET(fd, write_fdset_ptr);
+    if (pair.second.write_set)
+      FD_SET(fd, write_fdset_ptr);
 
-        if (pair.second.error_set)
-            FD_SET(fd, error_fdset_ptr);
-    }
+    if (pair.second.error_set)
+      FD_SET(fd, error_fdset_ptr);
+  }
 
-    //----------------------------------------------------------------------
-    // Setup our timeout time value if needed
-    //----------------------------------------------------------------------
-    struct timeval *tv_ptr = nullptr;
-    struct timeval tv = {0, 0};
+  //----------------------------------------------------------------------
+  // Setup our timeout time value if needed
+  //----------------------------------------------------------------------
+  struct timeval *tv_ptr = nullptr;
+  struct timeval tv = {0, 0};
 
-    while (1)
-    {
-        using namespace std::chrono;
-        //------------------------------------------------------------------
-        // Setup out relative timeout based on the end time if we have one
-        //------------------------------------------------------------------
-        if (m_end_time.hasValue())
-        {
-            tv_ptr = &tv;
-            const auto remaining_dur = duration_cast<microseconds>(m_end_time.getValue() - steady_clock::now());
-            if (remaining_dur.count() > 0)
-            {
-                // Wait for a specific amount of time
-                const auto dur_secs = duration_cast<seconds>(remaining_dur);
-                const auto dur_usecs = remaining_dur % seconds(1);
-                tv.tv_sec = dur_secs.count();
-                tv.tv_usec = dur_usecs.count();
-            }
-            else
-            {
-                // Just poll once with no timeout
-                tv.tv_sec = 0;
-                tv.tv_usec = 0;
-            }
-        }
-        const int num_set_fds = ::select(nfds, read_fdset_ptr, write_fdset_ptr, error_fdset_ptr, tv_ptr);
-        if (num_set_fds < 0)
-        {
-            // We got an error
-            error.SetErrorToErrno();
-            if (error.GetError() == EINTR)
-            {
-                error.Clear();
-                continue; // Keep calling select if we get EINTR
-            }
-            else
-                return error;
+  while (1) {
+    using namespace std::chrono;
+    //------------------------------------------------------------------
+    // Setup out relative timeout based on the end time if we have one
+    //------------------------------------------------------------------
+    if (m_end_time.hasValue()) {
+      tv_ptr = &tv;
+      const auto remaining_dur = duration_cast<microseconds>(
+          m_end_time.getValue() - steady_clock::now());
+      if (remaining_dur.count() > 0) {
+        // Wait for a specific amount of time
+        const auto dur_secs = duration_cast<seconds>(remaining_dur);
+        const auto dur_usecs = remaining_dur % seconds(1);
+        tv.tv_sec = dur_secs.count();
+        tv.tv_usec = dur_usecs.count();
+      } else {
+        // Just poll once with no timeout
+        tv.tv_sec = 0;
+        tv.tv_usec = 0;
+      }
+    }
+    const int num_set_fds = ::select(nfds, read_fdset_ptr, write_fdset_ptr,
+                                     error_fdset_ptr, tv_ptr);
+    if (num_set_fds < 0) {
+      // We got an error
+      error.SetErrorToErrno();
+      if (error.GetError() == EINTR) {
+        error.Clear();
+        continue; // Keep calling select if we get EINTR
+      } else
+        return error;
+    } else if (num_set_fds == 0) {
+      // Timeout
+      error.SetError(ETIMEDOUT, lldb::eErrorTypePOSIX);
+      error.SetErrorString("timed out");
+      return error;
+    } else {
+      // One or more descriptors were set, update the FDInfo::select_is_set mask
+      // so users can ask the SelectHelper class so clients can call one of:
+
+      for (auto &pair : m_fd_map) {
+        const int fd = pair.first;
+
+        if (pair.second.read_set) {
+          if (FD_ISSET(fd, read_fdset_ptr))
+            pair.second.read_is_set = true;
         }
-        else if (num_set_fds == 0)
-        {
-            // Timeout
-            error.SetError(ETIMEDOUT, lldb::eErrorTypePOSIX);
-            error.SetErrorString("timed out");
-            return error;
+        if (pair.second.write_set) {
+          if (FD_ISSET(fd, write_fdset_ptr))
+            pair.second.write_is_set = true;
         }
-        else
-        {
-            // One or more descriptors were set, update the FDInfo::select_is_set mask
-            // so users can ask the SelectHelper class so clients can call one of:
-
-            for (auto &pair : m_fd_map)
-            {
-                const int fd = pair.first;
-
-                if (pair.second.read_set)
-                {
-                    if (FD_ISSET(fd, read_fdset_ptr))
-                        pair.second.read_is_set = true;
-                }
-                if (pair.second.write_set)
-                {
-                    if (FD_ISSET(fd, write_fdset_ptr))
-                        pair.second.write_is_set = true;
-                }
-                if (pair.second.error_set)
-                {
-                    if (FD_ISSET(fd, error_fdset_ptr))
-                        pair.second.error_is_set = true;
-                }
-            }
-            break;
+        if (pair.second.error_set) {
+          if (FD_ISSET(fd, error_fdset_ptr))
+            pair.second.error_is_set = true;
         }
+      }
+      break;
     }
-    return error;
+  }
+  return error;
 }