*** 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, 217 insertions, 276 deletions

diff --git a/lldb/unittests/Editline/EditlineTest.cpp b/lldb/unittests/Editline/EditlineTest.cpp
index e2552ff..55dae52 100644
--- a/lldb/unittests/Editline/EditlineTest.cpp
+++ b/lldb/unittests/Editline/EditlineTest.cpp
@@ -25,348 +25,289 @@
 #include "lldb/Host/Pipe.h"
 #include "lldb/Utility/PseudoTerminal.h"
 
-namespace
-{
-    const size_t TIMEOUT_MILLIS = 5000;
+namespace {
+const size_t TIMEOUT_MILLIS = 5000;
 }
 
-class FilePointer
-{
+class FilePointer {
 public:
+  FilePointer() = delete;
 
-    FilePointer () = delete;
+  FilePointer(const FilePointer &) = delete;
 
-    FilePointer (const FilePointer&) = delete;
+  FilePointer(FILE *file_p) : _file_p(file_p) {}
 
-    FilePointer (FILE *file_p)
-    : _file_p (file_p)
-    {
+  ~FilePointer() {
+    if (_file_p != nullptr) {
+      const int close_result = fclose(_file_p);
+      EXPECT_EQ(0, close_result);
     }
+  }
 
-    ~FilePointer ()
-    {
-        if (_file_p != nullptr)
-        {
-            const int close_result = fclose (_file_p);
-            EXPECT_EQ(0, close_result);
-        }
-    }
-
-    operator FILE* ()
-    {
-        return _file_p;
-    }
+  operator FILE *() { return _file_p; }
 
 private:
-
-    FILE *_file_p;
-
+  FILE *_file_p;
 };
 
 /**
  Wraps an Editline class, providing a simple way to feed
  input (as if from the keyboard) and receive output from Editline.
  */
-class EditlineAdapter
-{
+class EditlineAdapter {
 public:
+  EditlineAdapter();
 
-    EditlineAdapter ();
+  void CloseInput();
 
-    void
-    CloseInput ();
+  bool IsValid() const { return _editline_sp.get() != nullptr; }
 
-    bool
-    IsValid () const
-    {
-        return _editline_sp.get () != nullptr;
-    }
+  lldb_private::Editline &GetEditline() { return *_editline_sp; }
 
-    lldb_private::Editline&
-    GetEditline ()
-    {
-        return *_editline_sp;
-    }
+  bool SendLine(const std::string &line);
 
-    bool
-    SendLine (const std::string &line);
+  bool SendLines(const std::vector<std::string> &lines);
 
-    bool
-    SendLines (const std::vector<std::string> &lines);
+  bool GetLine(std::string &line, bool &interrupted, size_t timeout_millis);
 
-    bool
-    GetLine (std::string &line, bool &interrupted, size_t timeout_millis);
+  bool GetLines(lldb_private::StringList &lines, bool &interrupted,
+                size_t timeout_millis);
 
-    bool
-    GetLines (lldb_private::StringList &lines, bool &interrupted, size_t timeout_millis);
-
-    void
-    ConsumeAllOutput ();
+  void ConsumeAllOutput();
 
 private:
+  static bool IsInputComplete(lldb_private::Editline *editline,
+                              lldb_private::StringList &lines, void *baton);
 
-    static bool
-    IsInputComplete (
-        lldb_private::Editline * editline,
-        lldb_private::StringList & lines,
-        void * baton);
-
-    std::unique_ptr<lldb_private::Editline> _editline_sp;
+  std::unique_ptr<lldb_private::Editline> _editline_sp;
 
-    lldb_utility::PseudoTerminal _pty;
-    int _pty_master_fd;
-    int _pty_slave_fd;
+  lldb_utility::PseudoTerminal _pty;
+  int _pty_master_fd;
+  int _pty_slave_fd;
 
-    std::unique_ptr<FilePointer> _el_slave_file;
+  std::unique_ptr<FilePointer> _el_slave_file;
 };
 
-EditlineAdapter::EditlineAdapter () :
-    _editline_sp (),
-    _pty (),
-    _pty_master_fd (-1),
-    _pty_slave_fd (-1),
-    _el_slave_file ()
-{
-    lldb_private::Error error;
-
-    // Open the first master pty available.
-    char error_string[256];
-    error_string[0] = '\0';
-    if (!_pty.OpenFirstAvailableMaster (O_RDWR, error_string, sizeof (error_string)))
-    {
-        fprintf(stderr, "failed to open first available master pty: '%s'\n", error_string);
-        return;
-    }
-
-    // Grab the master fd.  This is a file descriptor we will:
-    // (1) write to when we want to send input to editline.
-    // (2) read from when we want to see what editline sends back.
-    _pty_master_fd = _pty.GetMasterFileDescriptor();
-
-    // Open the corresponding slave pty.
-    if (!_pty.OpenSlave (O_RDWR, error_string, sizeof (error_string)))
-    {
-        fprintf(stderr, "failed to open slave pty: '%s'\n", error_string);
-        return;
-    }
-    _pty_slave_fd = _pty.GetSlaveFileDescriptor();
+EditlineAdapter::EditlineAdapter()
+    : _editline_sp(), _pty(), _pty_master_fd(-1), _pty_slave_fd(-1),
+      _el_slave_file() {
+  lldb_private::Error error;
+
+  // Open the first master pty available.
+  char error_string[256];
+  error_string[0] = '\0';
+  if (!_pty.OpenFirstAvailableMaster(O_RDWR, error_string,
+                                     sizeof(error_string))) {
+    fprintf(stderr, "failed to open first available master pty: '%s'\n",
+            error_string);
+    return;
+  }
+
+  // Grab the master fd.  This is a file descriptor we will:
+  // (1) write to when we want to send input to editline.
+  // (2) read from when we want to see what editline sends back.
+  _pty_master_fd = _pty.GetMasterFileDescriptor();
+
+  // Open the corresponding slave pty.
+  if (!_pty.OpenSlave(O_RDWR, error_string, sizeof(error_string))) {
+    fprintf(stderr, "failed to open slave pty: '%s'\n", error_string);
+    return;
+  }
+  _pty_slave_fd = _pty.GetSlaveFileDescriptor();
+
+  _el_slave_file.reset(new FilePointer(fdopen(_pty_slave_fd, "rw")));
+  EXPECT_FALSE(nullptr == *_el_slave_file);
+  if (*_el_slave_file == nullptr)
+    return;
+
+  // Create an Editline instance.
+  _editline_sp.reset(new lldb_private::Editline("gtest editor", *_el_slave_file,
+                                                *_el_slave_file,
+                                                *_el_slave_file, false));
+  _editline_sp->SetPrompt("> ");
+
+  // Hookup our input complete callback.
+  _editline_sp->SetIsInputCompleteCallback(IsInputComplete, this);
+}
 
-    _el_slave_file.reset (new FilePointer (fdopen (_pty_slave_fd, "rw")));
-    EXPECT_FALSE (nullptr == *_el_slave_file);
-    if (*_el_slave_file == nullptr)
-        return;
+void EditlineAdapter::CloseInput() {
+  if (_el_slave_file != nullptr)
+    _el_slave_file.reset(nullptr);
+}
 
-    // Create an Editline instance.
-    _editline_sp.reset (new lldb_private::Editline("gtest editor", *_el_slave_file, *_el_slave_file, *_el_slave_file, false));
-    _editline_sp->SetPrompt ("> ");
+bool EditlineAdapter::SendLine(const std::string &line) {
+  // Ensure we're valid before proceeding.
+  if (!IsValid())
+    return false;
 
-    // Hookup our input complete callback.
-    _editline_sp->SetIsInputCompleteCallback(IsInputComplete, this);
-}
+  // Write the line out to the pipe connected to editline's input.
+  ssize_t input_bytes_written =
+      ::write(_pty_master_fd, line.c_str(),
+              line.length() * sizeof(std::string::value_type));
 
-void
-EditlineAdapter::CloseInput ()
-{
-    if (_el_slave_file != nullptr)
-        _el_slave_file.reset (nullptr);
-}
+  const char *eoln = "\n";
+  const size_t eoln_length = strlen(eoln);
+  input_bytes_written =
+      ::write(_pty_master_fd, eoln, eoln_length * sizeof(char));
 
-bool
-EditlineAdapter::SendLine (const std::string &line)
-{
-    // Ensure we're valid before proceeding.
-    if (!IsValid ())
-        return false;
-
-    // Write the line out to the pipe connected to editline's input.
-    ssize_t input_bytes_written =
-        ::write (_pty_master_fd,
-                 line.c_str(),
-                 line.length() * sizeof (std::string::value_type));
-
-    const char *eoln = "\n";
-    const size_t eoln_length = strlen(eoln);
-    input_bytes_written =
-        ::write (_pty_master_fd,
-                 eoln,
-                 eoln_length * sizeof (char));
-
-    EXPECT_NE(-1, input_bytes_written) << strerror(errno);
-    EXPECT_EQ (eoln_length * sizeof (char), size_t(input_bytes_written));
-    return eoln_length * sizeof (char) == size_t(input_bytes_written);
+  EXPECT_NE(-1, input_bytes_written) << strerror(errno);
+  EXPECT_EQ(eoln_length * sizeof(char), size_t(input_bytes_written));
+  return eoln_length * sizeof(char) == size_t(input_bytes_written);
 }
 
-bool
-EditlineAdapter::SendLines (const std::vector<std::string> &lines)
-{
-    for (auto &line : lines)
-    {
+bool EditlineAdapter::SendLines(const std::vector<std::string> &lines) {
+  for (auto &line : lines) {
 #if EDITLINE_TEST_DUMP_OUTPUT
-        printf ("<stdin> sending line \"%s\"\n", line.c_str());
+    printf("<stdin> sending line \"%s\"\n", line.c_str());
 #endif
-        if (!SendLine (line))
-            return false;
-    }
-    return true;
+    if (!SendLine(line))
+      return false;
+  }
+  return true;
 }
 
 // We ignore the timeout for now.
-bool
-EditlineAdapter::GetLine (std::string &line, bool &interrupted, size_t /* timeout_millis */)
-{
-    // Ensure we're valid before proceeding.
-    if (!IsValid ())
-        return false;
-
-    _editline_sp->GetLine (line, interrupted);
-    return true;
+bool EditlineAdapter::GetLine(std::string &line, bool &interrupted,
+                              size_t /* timeout_millis */) {
+  // Ensure we're valid before proceeding.
+  if (!IsValid())
+    return false;
+
+  _editline_sp->GetLine(line, interrupted);
+  return true;
 }
 
-bool
-EditlineAdapter::GetLines (lldb_private::StringList &lines, bool &interrupted, size_t /* timeout_millis */)
-{
-    // Ensure we're valid before proceeding.
-    if (!IsValid ())
-        return false;
-    
-    _editline_sp->GetLines (1, lines, interrupted);
-    return true;
+bool EditlineAdapter::GetLines(lldb_private::StringList &lines,
+                               bool &interrupted, size_t /* timeout_millis */) {
+  // Ensure we're valid before proceeding.
+  if (!IsValid())
+    return false;
+
+  _editline_sp->GetLines(1, lines, interrupted);
+  return true;
 }
 
-bool
-EditlineAdapter::IsInputComplete (
-        lldb_private::Editline * editline,
-        lldb_private::StringList & lines,
-        void * baton)
-{
-    // We'll call ourselves complete if we've received a balanced set of braces.
-    int start_block_count = 0;
-    int brace_balance = 0;
-
-    for (size_t i = 0; i < lines.GetSize (); ++i)
-    {
-        for (auto ch : lines[i])
-        {
-            if (ch == '{')
-            {
-                ++start_block_count;
-                ++brace_balance;
-            }
-            else if (ch == '}')
-                --brace_balance;
-        }
+bool EditlineAdapter::IsInputComplete(lldb_private::Editline *editline,
+                                      lldb_private::StringList &lines,
+                                      void *baton) {
+  // We'll call ourselves complete if we've received a balanced set of braces.
+  int start_block_count = 0;
+  int brace_balance = 0;
+
+  for (size_t i = 0; i < lines.GetSize(); ++i) {
+    for (auto ch : lines[i]) {
+      if (ch == '{') {
+        ++start_block_count;
+        ++brace_balance;
+      } else if (ch == '}')
+        --brace_balance;
     }
+  }
 
-    return (start_block_count > 0) && (brace_balance == 0);
+  return (start_block_count > 0) && (brace_balance == 0);
 }
 
-void
-EditlineAdapter::ConsumeAllOutput ()
-{
-    FilePointer output_file (fdopen (_pty_master_fd, "r"));
+void EditlineAdapter::ConsumeAllOutput() {
+  FilePointer output_file(fdopen(_pty_master_fd, "r"));
 
-    int ch;
-    while ((ch = fgetc(output_file)) != EOF)
-    {
+  int ch;
+  while ((ch = fgetc(output_file)) != EOF) {
 #if EDITLINE_TEST_DUMP_OUTPUT
-        char display_str[] = { 0, 0, 0 };
-        switch (ch)
-        {
-            case '\t':
-                display_str[0] = '\\';
-                display_str[1] = 't';
-                break;
-            case '\n':
-                display_str[0] = '\\';
-                display_str[1] = 'n';
-                break;
-            case '\r':
-                display_str[0] = '\\';
-                display_str[1] = 'r';
-                break;
-            default:
-                display_str[0] = ch;
-                break;
-        }
-        printf ("<stdout> 0x%02x (%03d) (%s)\n", ch, ch, display_str);
-        // putc(ch, stdout);
-#endif
+    char display_str[] = {0, 0, 0};
+    switch (ch) {
+    case '\t':
+      display_str[0] = '\\';
+      display_str[1] = 't';
+      break;
+    case '\n':
+      display_str[0] = '\\';
+      display_str[1] = 'n';
+      break;
+    case '\r':
+      display_str[0] = '\\';
+      display_str[1] = 'r';
+      break;
+    default:
+      display_str[0] = ch;
+      break;
     }
+    printf("<stdout> 0x%02x (%03d) (%s)\n", ch, ch, display_str);
+// putc(ch, stdout);
+#endif
+  }
 }
 
-class EditlineTestFixture : public ::testing::Test
-{
+class EditlineTestFixture : public ::testing::Test {
 private:
-    EditlineAdapter _el_adapter;
-    std::shared_ptr<std::thread> _sp_output_thread;
+  EditlineAdapter _el_adapter;
+  std::shared_ptr<std::thread> _sp_output_thread;
 
 public:
-    void SetUp()
-    {
-        // We need a TERM set properly for editline to work as expected.
-        setenv("TERM", "vt100", 1);
-
-        // Validate the editline adapter.
-        EXPECT_TRUE(_el_adapter.IsValid());
-        if (!_el_adapter.IsValid())
-            return;
-
-        // Dump output.
-        _sp_output_thread.reset(new std::thread([&] { _el_adapter.ConsumeAllOutput(); }));
-    }
-
-    void TearDown()
-    {
-        _el_adapter.CloseInput();
-        if (_sp_output_thread)
-            _sp_output_thread->join();
-    }
-
-    EditlineAdapter &GetEditlineAdapter() { return _el_adapter; }
+  void SetUp() {
+    // We need a TERM set properly for editline to work as expected.
+    setenv("TERM", "vt100", 1);
+
+    // Validate the editline adapter.
+    EXPECT_TRUE(_el_adapter.IsValid());
+    if (!_el_adapter.IsValid())
+      return;
+
+    // Dump output.
+    _sp_output_thread.reset(
+        new std::thread([&] { _el_adapter.ConsumeAllOutput(); }));
+  }
+
+  void TearDown() {
+    _el_adapter.CloseInput();
+    if (_sp_output_thread)
+      _sp_output_thread->join();
+  }
+
+  EditlineAdapter &GetEditlineAdapter() { return _el_adapter; }
 };
 
-TEST_F(EditlineTestFixture, EditlineReceivesSingleLineText)
-{
-    // Send it some text via our virtual keyboard.
-    const std::string input_text ("Hello, world");
-    EXPECT_TRUE(GetEditlineAdapter().SendLine(input_text));
+TEST_F(EditlineTestFixture, EditlineReceivesSingleLineText) {
+  // Send it some text via our virtual keyboard.
+  const std::string input_text("Hello, world");
+  EXPECT_TRUE(GetEditlineAdapter().SendLine(input_text));
 
-    // Verify editline sees what we put in.
-    std::string el_reported_line;
-    bool input_interrupted = false;
-    const bool received_line = GetEditlineAdapter().GetLine(el_reported_line, input_interrupted, TIMEOUT_MILLIS);
+  // Verify editline sees what we put in.
+  std::string el_reported_line;
+  bool input_interrupted = false;
+  const bool received_line = GetEditlineAdapter().GetLine(
+      el_reported_line, input_interrupted, TIMEOUT_MILLIS);
 
-    EXPECT_TRUE (received_line);
-    EXPECT_FALSE (input_interrupted);
-    EXPECT_EQ (input_text, el_reported_line);
+  EXPECT_TRUE(received_line);
+  EXPECT_FALSE(input_interrupted);
+  EXPECT_EQ(input_text, el_reported_line);
 }
 
-TEST_F(EditlineTestFixture, EditlineReceivesMultiLineText)
-{
-    // Send it some text via our virtual keyboard.
-    std::vector<std::string> input_lines;
-    input_lines.push_back ("int foo()");
-    input_lines.push_back ("{");
-    input_lines.push_back ("printf(\"Hello, world\");");
-    input_lines.push_back ("}");
-    input_lines.push_back ("");
-
-    EXPECT_TRUE(GetEditlineAdapter().SendLines(input_lines));
-
-    // Verify editline sees what we put in.
-    lldb_private::StringList el_reported_lines;
-    bool input_interrupted = false;
-
-    EXPECT_TRUE(GetEditlineAdapter().GetLines(el_reported_lines, input_interrupted, TIMEOUT_MILLIS));
-    EXPECT_FALSE (input_interrupted);
-
-    // Without any auto indentation support, our output should directly match our input.
-    EXPECT_EQ (input_lines.size (), el_reported_lines.GetSize ());
-    if (input_lines.size () == el_reported_lines.GetSize ())
-    {
-        for (size_t i = 0; i < input_lines.size(); ++i)
-            EXPECT_EQ (input_lines[i], el_reported_lines[i]);
-    }
+TEST_F(EditlineTestFixture, EditlineReceivesMultiLineText) {
+  // Send it some text via our virtual keyboard.
+  std::vector<std::string> input_lines;
+  input_lines.push_back("int foo()");
+  input_lines.push_back("{");
+  input_lines.push_back("printf(\"Hello, world\");");
+  input_lines.push_back("}");
+  input_lines.push_back("");
+
+  EXPECT_TRUE(GetEditlineAdapter().SendLines(input_lines));
+
+  // Verify editline sees what we put in.
+  lldb_private::StringList el_reported_lines;
+  bool input_interrupted = false;
+
+  EXPECT_TRUE(GetEditlineAdapter().GetLines(el_reported_lines,
+                                            input_interrupted, TIMEOUT_MILLIS));
+  EXPECT_FALSE(input_interrupted);
+
+  // Without any auto indentation support, our output should directly match our
+  // input.
+  EXPECT_EQ(input_lines.size(), el_reported_lines.GetSize());
+  if (input_lines.size() == el_reported_lines.GetSize()) {
+    for (size_t i = 0; i < input_lines.size(); ++i)
+      EXPECT_EQ(input_lines[i], el_reported_lines[i]);
+  }
 }
 
 #endif